LLVM  16.0.0git
OMPContext.cpp
Go to the documentation of this file.
1 //===- OMPContext.cpp ------ Collection of helpers for OpenMP contexts ----===//
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 /// \file
9 ///
10 /// This file implements helper functions and classes to deal with OpenMP
11 /// contexts as used by `[begin/end] declare variant` and `metadirective`.
12 ///
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/ADT/StringSwitch.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/Support/Debug.h"
21 
22 #define DEBUG_TYPE "openmp-ir-builder"
23 
24 using namespace llvm;
25 using namespace omp;
26 
27 OMPContext::OMPContext(bool IsDeviceCompilation, Triple TargetTriple) {
28  // Add the appropriate device kind trait based on the triple and the
29  // IsDeviceCompilation flag.
30  ActiveTraits.set(unsigned(IsDeviceCompilation
31  ? TraitProperty::device_kind_nohost
32  : TraitProperty::device_kind_host));
33  switch (TargetTriple.getArch()) {
34  case Triple::arm:
35  case Triple::armeb:
36  case Triple::aarch64:
37  case Triple::aarch64_be:
38  case Triple::aarch64_32:
39  case Triple::mips:
40  case Triple::mipsel:
41  case Triple::mips64:
42  case Triple::mips64el:
43  case Triple::ppc:
44  case Triple::ppcle:
45  case Triple::ppc64:
46  case Triple::ppc64le:
47  case Triple::x86:
48  case Triple::x86_64:
49  ActiveTraits.set(unsigned(TraitProperty::device_kind_cpu));
50  break;
51  case Triple::amdgcn:
52  case Triple::nvptx:
53  case Triple::nvptx64:
54  ActiveTraits.set(unsigned(TraitProperty::device_kind_gpu));
55  break;
56  default:
57  break;
58  }
59 
60  // Add the appropriate device architecture trait based on the triple.
61 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
62  if (TraitSelector::TraitSelectorEnum == TraitSelector::device_arch) { \
63  if (TargetTriple.getArch() == TargetTriple.getArchTypeForLLVMName(Str)) \
64  ActiveTraits.set(unsigned(TraitProperty::Enum)); \
65  if (StringRef(Str) == StringRef("x86_64") && \
66  TargetTriple.getArch() == Triple::x86_64) \
67  ActiveTraits.set(unsigned(TraitProperty::Enum)); \
68  }
69 #include "llvm/Frontend/OpenMP/OMPKinds.def"
70 
71  // TODO: What exactly do we want to see as device ISA trait?
72  // The discussion on the list did not seem to have come to an agreed
73  // upon solution.
74 
75  // LLVM is the "OpenMP vendor" but we could also interpret vendor as the
76  // target vendor.
77  ActiveTraits.set(unsigned(TraitProperty::implementation_vendor_llvm));
78 
79  // The user condition true is accepted but not false.
80  ActiveTraits.set(unsigned(TraitProperty::user_condition_true));
81 
82  // This is for sure some device.
83  ActiveTraits.set(unsigned(TraitProperty::device_kind_any));
84 
85  LLVM_DEBUG({
86  dbgs() << "[" << DEBUG_TYPE
87  << "] New OpenMP context with the following properties:\n";
88  for (unsigned Bit : ActiveTraits.set_bits()) {
89  TraitProperty Property = TraitProperty(Bit);
90  dbgs() << "\t " << getOpenMPContextTraitPropertyFullName(Property)
91  << "\n";
92  }
93  });
94 }
95 
96 /// Return true if \p C0 is a subset of \p C1. Note that both arrays are
97 /// expected to be sorted.
98 template <typename T> static bool isSubset(ArrayRef<T> C0, ArrayRef<T> C1) {
99 #ifdef EXPENSIVE_CHECKS
101  "Expected sorted arrays!");
102 #endif
103  if (C0.size() > C1.size())
104  return false;
105  auto It0 = C0.begin(), End0 = C0.end();
106  auto It1 = C1.begin(), End1 = C1.end();
107  while (It0 != End0) {
108  if (It1 == End1)
109  return false;
110  if (*It0 == *It1) {
111  ++It0;
112  ++It1;
113  continue;
114  }
115  ++It0;
116  }
117  return true;
118 }
119 
120 /// Return true if \p C0 is a strict subset of \p C1. Note that both arrays are
121 /// expected to be sorted.
122 template <typename T>
124  if (C0.size() >= C1.size())
125  return false;
126  return isSubset<T>(C0, C1);
127 }
128 
129 static bool isStrictSubset(const VariantMatchInfo &VMI0,
130  const VariantMatchInfo &VMI1) {
131  // If all required traits are a strict subset and the ordered vectors storing
132  // the construct traits, we say it is a strict subset. Note that the latter
133  // relation is not required to be strict.
134  if (VMI0.RequiredTraits.count() >= VMI1.RequiredTraits.count())
135  return false;
136  for (unsigned Bit : VMI0.RequiredTraits.set_bits())
137  if (!VMI1.RequiredTraits.test(Bit))
138  return false;
139  if (!isSubset<TraitProperty>(VMI0.ConstructTraits, VMI1.ConstructTraits))
140  return false;
141  return true;
142 }
143 
145  const VariantMatchInfo &VMI, const OMPContext &Ctx,
146  SmallVectorImpl<unsigned> *ConstructMatches, bool DeviceSetOnly) {
147 
148  // The match kind determines if we need to match all traits, any of the
149  // traits, or none of the traits for it to be an applicable context.
150  enum MatchKind { MK_ALL, MK_ANY, MK_NONE };
151 
152  MatchKind MK = MK_ALL;
153  // Determine the match kind the user wants, "all" is the default and provided
154  // to the user only for completeness.
155  if (VMI.RequiredTraits.test(
156  unsigned(TraitProperty::implementation_extension_match_any)))
157  MK = MK_ANY;
158  if (VMI.RequiredTraits.test(
159  unsigned(TraitProperty::implementation_extension_match_none)))
160  MK = MK_NONE;
161 
162  // Helper to deal with a single property that was (not) found in the OpenMP
163  // context based on the match kind selected by the user via
164  // `implementation={extensions(match_[all,any,none])}'
165  auto HandleTrait = [MK](TraitProperty Property,
166  bool WasFound) -> Optional<bool> /* Result */ {
167  // For kind "any" a single match is enough but we ignore non-matched
168  // properties.
169  if (MK == MK_ANY) {
170  if (WasFound)
171  return true;
172  return None;
173  }
174 
175  // In "all" or "none" mode we accept a matching or non-matching property
176  // respectively and move on. We are not done yet!
177  if ((WasFound && MK == MK_ALL) || (!WasFound && MK == MK_NONE))
178  return None;
179 
180  // We missed a property, provide some debug output and indicate failure.
181  LLVM_DEBUG({
182  if (MK == MK_ALL)
183  dbgs() << "[" << DEBUG_TYPE << "] Property "
184  << getOpenMPContextTraitPropertyName(Property, "")
185  << " was not in the OpenMP context but match kind is all.\n";
186  if (MK == MK_NONE)
187  dbgs() << "[" << DEBUG_TYPE << "] Property "
188  << getOpenMPContextTraitPropertyName(Property, "")
189  << " was in the OpenMP context but match kind is none.\n";
190  });
191  return false;
192  };
193 
194  for (unsigned Bit : VMI.RequiredTraits.set_bits()) {
195  TraitProperty Property = TraitProperty(Bit);
196  if (DeviceSetOnly &&
197  getOpenMPContextTraitSetForProperty(Property) != TraitSet::device)
198  continue;
199 
200  // So far all extensions are handled elsewhere, we skip them here as they
201  // are not part of the OpenMP context.
203  TraitSelector::implementation_extension)
204  continue;
205 
206  bool IsActiveTrait = Ctx.ActiveTraits.test(unsigned(Property));
207 
208  // We overwrite the isa trait as it is actually up to the OMPContext hook to
209  // check the raw string(s).
210  if (Property == TraitProperty::device_isa___ANY)
211  IsActiveTrait = llvm::all_of(VMI.ISATraits, [&](StringRef RawString) {
212  return Ctx.matchesISATrait(RawString);
213  });
214 
215  Optional<bool> Result = HandleTrait(Property, IsActiveTrait);
216  if (Result)
217  return Result.value();
218  }
219 
220  if (!DeviceSetOnly) {
221  // We could use isSubset here but we also want to record the match
222  // locations.
223  unsigned ConstructIdx = 0, NoConstructTraits = Ctx.ConstructTraits.size();
224  for (TraitProperty Property : VMI.ConstructTraits) {
226  TraitSet::construct &&
227  "Variant context is ill-formed!");
228 
229  // Verify the nesting.
230  bool FoundInOrder = false;
231  while (!FoundInOrder && ConstructIdx != NoConstructTraits)
232  FoundInOrder = (Ctx.ConstructTraits[ConstructIdx++] == Property);
233  if (ConstructMatches)
234  ConstructMatches->push_back(ConstructIdx - 1);
235 
236  Optional<bool> Result = HandleTrait(Property, FoundInOrder);
237  if (Result)
238  return Result.value();
239 
240  if (!FoundInOrder) {
241  LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE << "] Construct property "
242  << getOpenMPContextTraitPropertyName(Property, "")
243  << " was not nested properly.\n");
244  return false;
245  }
246 
247  // TODO: Verify SIMD
248  }
249 
250  assert(isSubset<TraitProperty>(VMI.ConstructTraits, Ctx.ConstructTraits) &&
251  "Broken invariant!");
252  }
253 
254  if (MK == MK_ANY) {
255  LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE
256  << "] None of the properties was in the OpenMP context "
257  "but match kind is any.\n");
258  return false;
259  }
260 
261  return true;
262 }
263 
265  const OMPContext &Ctx,
266  bool DeviceSetOnly) {
268  VMI, Ctx, /* ConstructMatches */ nullptr, DeviceSetOnly);
269 }
270 
272  const OMPContext &Ctx,
273  SmallVectorImpl<unsigned> &ConstructMatches) {
274  APInt Score(64, 1);
275 
276  unsigned NoConstructTraits = VMI.ConstructTraits.size();
277  for (unsigned Bit : VMI.RequiredTraits.set_bits()) {
278  TraitProperty Property = TraitProperty(Bit);
279  // If there is a user score attached, use it.
280  if (VMI.ScoreMap.count(Property)) {
281  const APInt &UserScore = VMI.ScoreMap.lookup(Property);
282  assert(UserScore.uge(0) && "Expect non-negative user scores!");
283  Score += UserScore.getZExtValue();
284  continue;
285  }
286 
287  switch (getOpenMPContextTraitSetForProperty(Property)) {
288  case TraitSet::construct:
289  // We handle the construct traits later via the VMI.ConstructTraits
290  // container.
291  continue;
292  case TraitSet::implementation:
293  // No effect on the score (implementation defined).
294  continue;
295  case TraitSet::user:
296  // No effect on the score.
297  continue;
298  case TraitSet::device:
299  // Handled separately below.
300  break;
301  case TraitSet::invalid:
302  llvm_unreachable("Unknown trait set is not to be used!");
303  }
304 
305  // device={kind(any)} is "as if" no kind selector was specified.
306  if (Property == TraitProperty::device_kind_any)
307  continue;
308 
309  switch (getOpenMPContextTraitSelectorForProperty(Property)) {
310  case TraitSelector::device_kind:
311  Score += (1ULL << (NoConstructTraits + 0));
312  continue;
313  case TraitSelector::device_arch:
314  Score += (1ULL << (NoConstructTraits + 1));
315  continue;
316  case TraitSelector::device_isa:
317  Score += (1ULL << (NoConstructTraits + 2));
318  continue;
319  default:
320  continue;
321  }
322  }
323 
324  unsigned ConstructIdx = 0;
325  assert(NoConstructTraits == ConstructMatches.size() &&
326  "Mismatch in the construct traits!");
327  for (TraitProperty Property : VMI.ConstructTraits) {
329  TraitSet::construct &&
330  "Ill-formed variant match info!");
331  (void)Property;
332  // ConstructMatches is the position p - 1 and we need 2^(p-1).
333  Score += (1ULL << ConstructMatches[ConstructIdx++]);
334  }
335 
336  LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE << "] Variant has a score of " << Score
337  << "\n");
338  return Score;
339 }
340 
342  const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx) {
343 
344  APInt BestScore(64, 0);
345  int BestVMIIdx = -1;
346  const VariantMatchInfo *BestVMI = nullptr;
347 
348  for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
349  const VariantMatchInfo &VMI = VMIs[u];
350 
351  SmallVector<unsigned, 8> ConstructMatches;
352  // If the variant is not applicable its not the best.
353  if (!isVariantApplicableInContextHelper(VMI, Ctx, &ConstructMatches,
354  /* DeviceSetOnly */ false))
355  continue;
356  // Check if its clearly not the best.
357  APInt Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
358  if (Score.ult(BestScore))
359  continue;
360  // Equal score need subset checks.
361  if (Score.eq(BestScore)) {
362  // Strict subset are never best.
363  if (isStrictSubset(VMI, *BestVMI))
364  continue;
365  // Same score and the current best is no strict subset so we keep it.
366  if (!isStrictSubset(*BestVMI, VMI))
367  continue;
368  }
369  // New best found.
370  BestVMI = &VMI;
371  BestVMIIdx = u;
372  BestScore = Score;
373  }
374 
375  return BestVMIIdx;
376 }
377 
379  return StringSwitch<TraitSet>(S)
380 #define OMP_TRAIT_SET(Enum, Str) .Case(Str, TraitSet::Enum)
381 #include "llvm/Frontend/OpenMP/OMPKinds.def"
382  .Default(TraitSet::invalid);
383 }
384 
385 TraitSet
387  switch (Selector) {
388 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \
389  case TraitSelector::Enum: \
390  return TraitSet::TraitSetEnum;
391 #include "llvm/Frontend/OpenMP/OMPKinds.def"
392  }
393  llvm_unreachable("Unknown trait selector!");
394 }
395 TraitSet
397  switch (Property) {
398 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
399  case TraitProperty::Enum: \
400  return TraitSet::TraitSetEnum;
401 #include "llvm/Frontend/OpenMP/OMPKinds.def"
402  }
403  llvm_unreachable("Unknown trait set!");
404 }
406  switch (Kind) {
407 #define OMP_TRAIT_SET(Enum, Str) \
408  case TraitSet::Enum: \
409  return Str;
410 #include "llvm/Frontend/OpenMP/OMPKinds.def"
411  }
412  llvm_unreachable("Unknown trait set!");
413 }
414 
417 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \
418  .Case(Str, TraitSelector::Enum)
419 #include "llvm/Frontend/OpenMP/OMPKinds.def"
420  .Default(TraitSelector::invalid);
421 }
424  switch (Property) {
425 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
426  case TraitProperty::Enum: \
427  return TraitSelector::TraitSelectorEnum;
428 #include "llvm/Frontend/OpenMP/OMPKinds.def"
429  }
430  llvm_unreachable("Unknown trait set!");
431 }
433  switch (Kind) {
434 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \
435  case TraitSelector::Enum: \
436  return Str;
437 #include "llvm/Frontend/OpenMP/OMPKinds.def"
438  }
439  llvm_unreachable("Unknown trait selector!");
440 }
441 
443  TraitSet Set, TraitSelector Selector, StringRef S) {
444  // Special handling for `device={isa(...)}` as we accept anything here. It is
445  // up to the target to decide if the feature is available.
446  if (Set == TraitSet::device && Selector == TraitSelector::device_isa)
447  return TraitProperty::device_isa___ANY;
448 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
449  if (Set == TraitSet::TraitSetEnum && Str == S) \
450  return TraitProperty::Enum;
451 #include "llvm/Frontend/OpenMP/OMPKinds.def"
452  return TraitProperty::invalid;
453 }
458 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
459  .Case(Str, Selector == TraitSelector::TraitSelectorEnum \
460  ? TraitProperty::Enum \
461  : TraitProperty::invalid)
462 #include "llvm/Frontend/OpenMP/OMPKinds.def"
463  .Default(TraitProperty::invalid);
464 }
466  StringRef RawString) {
467  if (Kind == TraitProperty::device_isa___ANY)
468  return RawString;
469  switch (Kind) {
470 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
471  case TraitProperty::Enum: \
472  return Str;
473 #include "llvm/Frontend/OpenMP/OMPKinds.def"
474  }
475  llvm_unreachable("Unknown trait property!");
476 }
478  switch (Kind) {
479 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
480  case TraitProperty::Enum: \
481  return "(" #TraitSetEnum "," #TraitSelectorEnum "," Str ")";
482 #include "llvm/Frontend/OpenMP/OMPKinds.def"
483  }
484  llvm_unreachable("Unknown trait property!");
485 }
486 
488  TraitSet Set,
489  bool &AllowsTraitScore,
490  bool &RequiresProperty) {
491  AllowsTraitScore = Set != TraitSet::construct && Set != TraitSet::device;
492  switch (Selector) {
493 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \
494  case TraitSelector::Enum: \
495  RequiresProperty = ReqProp; \
496  return Set == TraitSet::TraitSetEnum;
497 #include "llvm/Frontend/OpenMP/OMPKinds.def"
498  }
499  llvm_unreachable("Unknown trait selector!");
500 }
501 
503  TraitProperty Property, TraitSelector Selector, TraitSet Set) {
504  switch (Property) {
505 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
506  case TraitProperty::Enum: \
507  return Set == TraitSet::TraitSetEnum && \
508  Selector == TraitSelector::TraitSelectorEnum;
509 #include "llvm/Frontend/OpenMP/OMPKinds.def"
510  }
511  llvm_unreachable("Unknown trait property!");
512 }
513 
515  std::string S;
516 #define OMP_TRAIT_SET(Enum, Str) \
517  if (StringRef(Str) != "invalid") \
518  S.append("'").append(Str).append("'").append(" ");
519 #include "llvm/Frontend/OpenMP/OMPKinds.def"
520  S.pop_back();
521  return S;
522 }
523 
525  std::string S;
526 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \
527  if (TraitSet::TraitSetEnum == Set && StringRef(Str) != "Invalid") \
528  S.append("'").append(Str).append("'").append(" ");
529 #include "llvm/Frontend/OpenMP/OMPKinds.def"
530  S.pop_back();
531  return S;
532 }
533 
534 std::string
536  TraitSelector Selector) {
537  std::string S;
538 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
539  if (TraitSet::TraitSetEnum == Set && \
540  TraitSelector::TraitSelectorEnum == Selector && \
541  StringRef(Str) != "invalid") \
542  S.append("'").append(Str).append("'").append(" ");
543 #include "llvm/Frontend/OpenMP/OMPKinds.def"
544  if (S.empty())
545  return "<none>";
546  S.pop_back();
547  return S;
548 }
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
StringRef.h
llvm::BitVector::set
BitVector & set()
Definition: BitVector.h:344
llvm::omp::VariantMatchInfo
Variant match information describes the required traits and how they are scored (via the ScoresMap).
Definition: OMPContext.h:119
llvm::Triple::x86
@ x86
Definition: Triple.h:85
C1
instcombine should handle this C2 when C1
Definition: README.txt:263
llvm::SmallVector< unsigned, 8 >
llvm::Triple::amdgcn
@ amdgcn
Definition: Triple.h:74
llvm::omp::getOpenMPContextTraitPropertyForSelector
TraitProperty getOpenMPContextTraitPropertyForSelector(TraitSelector Selector)
Return the trait property for a singleton selector Selector.
Definition: OMPContext.cpp:455
llvm::omp::VariantMatchInfo::ScoreMap
SmallDenseMap< TraitProperty, APInt > ScoreMap
Definition: OMPContext.h:151
llvm::BitVector::set_bits
iterator_range< const_set_bits_iterator > set_bits() const
Definition: BitVector.h:133
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
llvm::Triple::x86_64
@ x86_64
Definition: Triple.h:86
llvm::Triple::ppc
@ ppc
Definition: Triple.h:69
llvm::Optional< bool >
llvm::Triple::nvptx
@ nvptx
Definition: Triple.h:88
llvm::omp::OMPContext::ActiveTraits
BitVector ActiveTraits
Definition: OMPContext.h:175
llvm::Triple::aarch64_32
@ aarch64_32
Definition: Triple.h:53
llvm::omp::getOpenMPContextTraitSelectorKind
TraitSelector getOpenMPContextTraitSelectorKind(StringRef Str)
Parse Str and return the trait set it matches or TraitSelector::invalid.
Definition: OMPContext.cpp:415
llvm::Triple::mips64
@ mips64
Definition: Triple.h:66
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::omp::TraitSet
TraitSet
OpenMP Context related IDs and helpers.
Definition: OMPContext.h:33
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::APInt::uge
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
Definition: APInt.h:1191
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1709
llvm::APInt::eq
bool eq(const APInt &RHS) const
Equality comparison.
Definition: APInt.h:1049
OMPContext.h
llvm::BitVector::count
size_type count() const
count - Returns the number of bits which are set.
Definition: BitVector.h:155
llvm::Triple::mips64el
@ mips64el
Definition: Triple.h:67
llvm::Triple::nvptx64
@ nvptx64
Definition: Triple.h:89
llvm::omp::getOpenMPContextTraitSetName
StringRef getOpenMPContextTraitSetName(TraitSet Kind)
Return a textual representation of the trait set Kind.
Definition: OMPContext.cpp:405
llvm::Triple::ppc64
@ ppc64
Definition: Triple.h:71
llvm::APInt::getZExtValue
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1486
isStrictSubset
static bool isStrictSubset(ArrayRef< T > C0, ArrayRef< T > C1)
Return true if C0 is a strict subset of C1.
Definition: OMPContext.cpp:123
llvm::Triple::getArch
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:354
llvm::omp::VariantMatchInfo::ConstructTraits
SmallVector< TraitProperty, 8 > ConstructTraits
Definition: OMPContext.h:150
llvm::omp::OMPContext::OMPContext
OMPContext(bool IsDeviceCompilation, Triple TargetTriple)
Definition: OMPContext.cpp:27
llvm::omp::listOpenMPContextTraitProperties
std::string listOpenMPContextTraitProperties(TraitSet Set, TraitSelector Selector)
Return a string listing all trait properties for Set and Selector.
Definition: OMPContext.cpp:535
llvm::omp::VariantMatchInfo::RequiredTraits
BitVector RequiredTraits
Definition: OMPContext.h:148
getVariantMatchScore
static APInt getVariantMatchScore(const VariantMatchInfo &VMI, const OMPContext &Ctx, SmallVectorImpl< unsigned > &ConstructMatches)
Definition: OMPContext.cpp:271
llvm::Triple::ppc64le
@ ppc64le
Definition: Triple.h:72
llvm::omp::getOpenMPContextTraitSelectorName
StringRef getOpenMPContextTraitSelectorName(TraitSelector Kind)
Return a textual representation of the trait selector Kind.
Definition: OMPContext.cpp:432
llvm::omp::listOpenMPContextTraitSelectors
std::string listOpenMPContextTraitSelectors(TraitSet Set)
Return a string listing all trait selectors for Set.
Definition: OMPContext.cpp:524
llvm::omp::getOpenMPContextTraitSetForSelector
TraitSet getOpenMPContextTraitSetForSelector(TraitSelector Selector)
Return the trait set for which Selector is a selector.
Definition: OMPContext.cpp:386
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:53
llvm::omp::listOpenMPContextTraitSets
std::string listOpenMPContextTraitSets()
Return a string listing all trait sets.
Definition: OMPContext.cpp:514
isVariantApplicableInContextHelper
static int isVariantApplicableInContextHelper(const VariantMatchInfo &VMI, const OMPContext &Ctx, SmallVectorImpl< unsigned > *ConstructMatches, bool DeviceSetOnly)
Definition: OMPContext.cpp:144
llvm::omp::isVariantApplicableInContext
bool isVariantApplicableInContext(const VariantMatchInfo &VMI, const OMPContext &Ctx, bool DeviceSetOnly=false)
Return true if VMI is applicable in Ctx, that is, all traits required by VMI are available in the Ope...
Definition: OMPContext.cpp:264
llvm::omp::OMPContext::ConstructTraits
SmallVector< TraitProperty, 8 > ConstructTraits
Definition: OMPContext.h:176
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::omp::TraitProperty
TraitProperty
IDs for all OpenMP context trait properties (host/gpu/bsc/llvm/...)
Definition: OMPContext.h:45
llvm::omp::getOpenMPContextTraitPropertyKind
TraitProperty getOpenMPContextTraitPropertyKind(TraitSet Set, TraitSelector Selector, StringRef Str)
Parse Str and return the trait property it matches in the set Set and selector Selector or TraitPrope...
Definition: OMPContext.cpp:442
llvm::Triple::armeb
@ armeb
Definition: Triple.h:50
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
Triple.h
llvm::omp::OMPContext
The context for a source location is made up of active property traits, e.g., device={kind(host)},...
Definition: OMPContext.h:157
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::Triple::arm
@ arm
Definition: Triple.h:49
llvm::Triple::aarch64_be
@ aarch64_be
Definition: Triple.h:52
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::Triple::ppcle
@ ppcle
Definition: Triple.h:70
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::omp::getOpenMPContextTraitSetForProperty
TraitSet getOpenMPContextTraitSetForProperty(TraitProperty Property)
Return the trait set for which Property is a property.
Definition: OMPContext.cpp:396
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::APInt::ult
bool ult(const APInt &RHS) const
Unsigned less than comparison.
Definition: APInt.h:1081
llvm::omp::isValidTraitPropertyForTraitSetAndSelector
bool isValidTraitPropertyForTraitSetAndSelector(TraitProperty Property, TraitSelector Selector, TraitSet Set)
Return true if Property can be nested in Selector and Set.
Definition: OMPContext.cpp:502
isSubset
static bool isSubset(ArrayRef< T > C0, ArrayRef< T > C1)
Return true if C0 is a subset of C1.
Definition: OMPContext.cpp:98
llvm::BitVector::test
bool test(unsigned Idx) const
Definition: BitVector.h:454
llvm::None
constexpr std::nullopt_t None
Definition: None.h:27
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:152
llvm::Triple::mipsel
@ mipsel
Definition: Triple.h:65
llvm::is_sorted
bool is_sorted(R &&Range, Compare C)
Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...
Definition: STLExtras.h:1858
llvm::omp::getOpenMPContextTraitSelectorForProperty
TraitSelector getOpenMPContextTraitSelectorForProperty(TraitProperty Property)
Return the trait selector for which Property is a property.
Definition: OMPContext.cpp:423
StringSwitch.h
llvm::omp::TraitSelector
TraitSelector
IDs for all OpenMP context selector trait (device={kind/isa...}/...).
Definition: OMPContext.h:39
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
llvm::tgtok::Bit
@ Bit
Definition: TGLexer.h:50
llvm::omp::getOpenMPContextTraitPropertyName
StringRef getOpenMPContextTraitPropertyName(TraitProperty Kind, StringRef RawString)
Return a textual representation of the trait property Kind, which might be the raw string we parsed (...
Definition: OMPContext.cpp:465
llvm::SmallVectorImpl< unsigned >
llvm::StringSwitch::Default
R Default(T Value)
Definition: StringSwitch.h:183
llvm::StringSwitch
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:45
llvm::omp::isValidTraitSelectorForTraitSet
bool isValidTraitSelectorForTraitSet(TraitSelector Selector, TraitSet Set, bool &AllowsTraitScore, bool &RequiresProperty)
}
Definition: OMPContext.cpp:487
raw_ostream.h
llvm::omp::getOpenMPContextTraitSetKind
TraitSet getOpenMPContextTraitSetKind(StringRef Str)
Parse Str and return the trait set it matches or TraitSet::invalid.
Definition: OMPContext.cpp:378
llvm::omp::getBestVariantMatchForContext
int getBestVariantMatchForContext(const SmallVectorImpl< VariantMatchInfo > &VMIs, const OMPContext &Ctx)
Return the index (into VMIs) of the variant with the highest score from the ones applicble in Ctx.
Definition: OMPContext.cpp:341
DEBUG_TYPE
#define DEBUG_TYPE
Definition: OMPContext.cpp:22
Debug.h
llvm::Triple::mips
@ mips
Definition: Triple.h:64
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:153
llvm::Triple::aarch64
@ aarch64
Definition: Triple.h:51
llvm::omp::getOpenMPContextTraitPropertyFullName
StringRef getOpenMPContextTraitPropertyFullName(TraitProperty Kind)
Return a textual representation of the trait property Kind with selector and set name included.
Definition: OMPContext.cpp:477
llvm::omp::VariantMatchInfo::ISATraits
SmallVector< StringRef, 8 > ISATraits
Definition: OMPContext.h:149