LLVM  15.0.0git
StringRef.cpp
Go to the documentation of this file.
1 //===-- StringRef.cpp - Lightweight String References ---------------------===//
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 "llvm/ADT/StringRef.h"
10 #include "llvm/ADT/APFloat.h"
11 #include "llvm/ADT/APInt.h"
12 #include "llvm/ADT/Hashing.h"
13 #include "llvm/ADT/StringExtras.h"
14 #include "llvm/ADT/edit_distance.h"
15 #include "llvm/Support/Error.h"
16 #include <bitset>
17 
18 using namespace llvm;
19 
20 // MSVC emits references to this into the translation units which reference it.
21 #ifndef _MSC_VER
22 constexpr size_t StringRef::npos;
23 #endif
24 
25 // strncasecmp() is not available on non-POSIX systems, so define an
26 // alternative function here.
27 static int ascii_strncasecmp(const char *LHS, const char *RHS, size_t Length) {
28  for (size_t I = 0; I < Length; ++I) {
29  unsigned char LHC = toLower(LHS[I]);
30  unsigned char RHC = toLower(RHS[I]);
31  if (LHC != RHC)
32  return LHC < RHC ? -1 : 1;
33  }
34  return 0;
35 }
36 
38  if (int Res = ascii_strncasecmp(Data, RHS.Data, std::min(Length, RHS.Length)))
39  return Res;
40  if (Length == RHS.Length)
41  return 0;
42  return Length < RHS.Length ? -1 : 1;
43 }
44 
46  return Length >= Prefix.Length &&
47  ascii_strncasecmp(Data, Prefix.Data, Prefix.Length) == 0;
48 }
49 
51  return Length >= Suffix.Length &&
52  ascii_strncasecmp(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
53 }
54 
55 size_t StringRef::find_insensitive(char C, size_t From) const {
56  char L = toLower(C);
57  return find_if([L](char D) { return toLower(D) == L; }, From);
58 }
59 
60 /// compare_numeric - Compare strings, handle embedded numbers.
62  for (size_t I = 0, E = std::min(Length, RHS.Length); I != E; ++I) {
63  // Check for sequences of digits.
64  if (isDigit(Data[I]) && isDigit(RHS.Data[I])) {
65  // The longer sequence of numbers is considered larger.
66  // This doesn't really handle prefixed zeros well.
67  size_t J;
68  for (J = I + 1; J != E + 1; ++J) {
69  bool ld = J < Length && isDigit(Data[J]);
70  bool rd = J < RHS.Length && isDigit(RHS.Data[J]);
71  if (ld != rd)
72  return rd ? -1 : 1;
73  if (!rd)
74  break;
75  }
76  // The two number sequences have the same length (J-I), just memcmp them.
77  if (int Res = compareMemory(Data + I, RHS.Data + I, J - I))
78  return Res < 0 ? -1 : 1;
79  // Identical number sequences, continue search after the numbers.
80  I = J - 1;
81  continue;
82  }
83  if (Data[I] != RHS.Data[I])
84  return (unsigned char)Data[I] < (unsigned char)RHS.Data[I] ? -1 : 1;
85  }
86  if (Length == RHS.Length)
87  return 0;
88  return Length < RHS.Length ? -1 : 1;
89 }
90 
91 // Compute the edit distance between the two given strings.
93  bool AllowReplacements,
94  unsigned MaxEditDistance) const {
96  makeArrayRef(data(), size()),
97  makeArrayRef(Other.data(), Other.size()),
98  AllowReplacements, MaxEditDistance);
99 }
100 
102  StringRef Other, bool AllowReplacements, unsigned MaxEditDistance) const {
104  makeArrayRef(data(), size()), makeArrayRef(Other.data(), Other.size()),
105  llvm::toLower, AllowReplacements, MaxEditDistance);
106 }
107 
108 //===----------------------------------------------------------------------===//
109 // String Operations
110 //===----------------------------------------------------------------------===//
111 
112 std::string StringRef::lower() const {
113  return std::string(map_iterator(begin(), toLower),
114  map_iterator(end(), toLower));
115 }
116 
117 std::string StringRef::upper() const {
118  return std::string(map_iterator(begin(), toUpper),
119  map_iterator(end(), toUpper));
120 }
121 
122 //===----------------------------------------------------------------------===//
123 // String Searching
124 //===----------------------------------------------------------------------===//
125 
126 
127 /// find - Search for the first string \arg Str in the string.
128 ///
129 /// \return - The index of the first occurrence of \arg Str, or npos if not
130 /// found.
131 size_t StringRef::find(StringRef Str, size_t From) const {
132  if (From > Length)
133  return npos;
134 
135  const char *Start = Data + From;
136  size_t Size = Length - From;
137 
138  const char *Needle = Str.data();
139  size_t N = Str.size();
140  if (N == 0)
141  return From;
142  if (Size < N)
143  return npos;
144  if (N == 1) {
145  const char *Ptr = (const char *)::memchr(Start, Needle[0], Size);
146  return Ptr == nullptr ? npos : Ptr - Data;
147  }
148 
149  const char *Stop = Start + (Size - N + 1);
150 
151  // For short haystacks or unsupported needles fall back to the naive algorithm
152  if (Size < 16 || N > 255) {
153  do {
154  if (std::memcmp(Start, Needle, N) == 0)
155  return Start - Data;
156  ++Start;
157  } while (Start < Stop);
158  return npos;
159  }
160 
161  // Build the bad char heuristic table, with uint8_t to reduce cache thrashing.
162  uint8_t BadCharSkip[256];
163  std::memset(BadCharSkip, N, 256);
164  for (unsigned i = 0; i != N-1; ++i)
165  BadCharSkip[(uint8_t)Str[i]] = N-1-i;
166 
167  do {
168  uint8_t Last = Start[N - 1];
169  if (LLVM_UNLIKELY(Last == (uint8_t)Needle[N - 1]))
170  if (std::memcmp(Start, Needle, N - 1) == 0)
171  return Start - Data;
172 
173  // Otherwise skip the appropriate number of bytes.
174  Start += BadCharSkip[Last];
175  } while (Start < Stop);
176 
177  return npos;
178 }
179 
180 size_t StringRef::find_insensitive(StringRef Str, size_t From) const {
182  while (This.size() >= Str.size()) {
183  if (This.startswith_insensitive(Str))
184  return From;
185  This = This.drop_front();
186  ++From;
187  }
188  return npos;
189 }
190 
191 size_t StringRef::rfind_insensitive(char C, size_t From) const {
192  From = std::min(From, Length);
193  size_t i = From;
194  while (i != 0) {
195  --i;
196  if (toLower(Data[i]) == toLower(C))
197  return i;
198  }
199  return npos;
200 }
201 
202 /// rfind - Search for the last string \arg Str in the string.
203 ///
204 /// \return - The index of the last occurrence of \arg Str, or npos if not
205 /// found.
206 size_t StringRef::rfind(StringRef Str) const {
207  size_t N = Str.size();
208  if (N > Length)
209  return npos;
210  for (size_t i = Length - N + 1, e = 0; i != e;) {
211  --i;
212  if (substr(i, N).equals(Str))
213  return i;
214  }
215  return npos;
216 }
217 
219  size_t N = Str.size();
220  if (N > Length)
221  return npos;
222  for (size_t i = Length - N + 1, e = 0; i != e;) {
223  --i;
224  if (substr(i, N).equals_insensitive(Str))
225  return i;
226  }
227  return npos;
228 }
229 
230 /// find_first_of - Find the first character in the string that is in \arg
231 /// Chars, or npos if not found.
232 ///
233 /// Note: O(size() + Chars.size())
235  size_t From) const {
236  std::bitset<1 << CHAR_BIT> CharBits;
237  for (char C : Chars)
238  CharBits.set((unsigned char)C);
239 
240  for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
241  if (CharBits.test((unsigned char)Data[i]))
242  return i;
243  return npos;
244 }
245 
246 /// find_first_not_of - Find the first character in the string that is not
247 /// \arg C or npos if not found.
249  for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
250  if (Data[i] != C)
251  return i;
252  return npos;
253 }
254 
255 /// find_first_not_of - Find the first character in the string that is not
256 /// in the string \arg Chars, or npos if not found.
257 ///
258 /// Note: O(size() + Chars.size())
260  size_t From) const {
261  std::bitset<1 << CHAR_BIT> CharBits;
262  for (char C : Chars)
263  CharBits.set((unsigned char)C);
264 
265  for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
266  if (!CharBits.test((unsigned char)Data[i]))
267  return i;
268  return npos;
269 }
270 
271 /// find_last_of - Find the last character in the string that is in \arg C,
272 /// or npos if not found.
273 ///
274 /// Note: O(size() + Chars.size())
276  size_t From) const {
277  std::bitset<1 << CHAR_BIT> CharBits;
278  for (char C : Chars)
279  CharBits.set((unsigned char)C);
280 
281  for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
282  if (CharBits.test((unsigned char)Data[i]))
283  return i;
284  return npos;
285 }
286 
287 /// find_last_not_of - Find the last character in the string that is not
288 /// \arg C, or npos if not found.
290  for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
291  if (Data[i] != C)
292  return i;
293  return npos;
294 }
295 
296 /// find_last_not_of - Find the last character in the string that is not in
297 /// \arg Chars, or npos if not found.
298 ///
299 /// Note: O(size() + Chars.size())
301  size_t From) const {
302  std::bitset<1 << CHAR_BIT> CharBits;
303  for (char C : Chars)
304  CharBits.set((unsigned char)C);
305 
306  for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
307  if (!CharBits.test((unsigned char)Data[i]))
308  return i;
309  return npos;
310 }
311 
313  StringRef Separator, int MaxSplit,
314  bool KeepEmpty) const {
315  StringRef S = *this;
316 
317  // Count down from MaxSplit. When MaxSplit is -1, this will just split
318  // "forever". This doesn't support splitting more than 2^31 times
319  // intentionally; if we ever want that we can make MaxSplit a 64-bit integer
320  // but that seems unlikely to be useful.
321  while (MaxSplit-- != 0) {
322  size_t Idx = S.find(Separator);
323  if (Idx == npos)
324  break;
325 
326  // Push this split.
327  if (KeepEmpty || Idx > 0)
328  A.push_back(S.slice(0, Idx));
329 
330  // Jump forward.
331  S = S.slice(Idx + Separator.size(), npos);
332  }
333 
334  // Push the tail.
335  if (KeepEmpty || !S.empty())
336  A.push_back(S);
337 }
338 
340  int MaxSplit, bool KeepEmpty) const {
341  StringRef S = *this;
342 
343  // Count down from MaxSplit. When MaxSplit is -1, this will just split
344  // "forever". This doesn't support splitting more than 2^31 times
345  // intentionally; if we ever want that we can make MaxSplit a 64-bit integer
346  // but that seems unlikely to be useful.
347  while (MaxSplit-- != 0) {
348  size_t Idx = S.find(Separator);
349  if (Idx == npos)
350  break;
351 
352  // Push this split.
353  if (KeepEmpty || Idx > 0)
354  A.push_back(S.slice(0, Idx));
355 
356  // Jump forward.
357  S = S.slice(Idx + 1, npos);
358  }
359 
360  // Push the tail.
361  if (KeepEmpty || !S.empty())
362  A.push_back(S);
363 }
364 
365 //===----------------------------------------------------------------------===//
366 // Helpful Algorithms
367 //===----------------------------------------------------------------------===//
368 
369 /// count - Return the number of non-overlapped occurrences of \arg Str in
370 /// the string.
371 size_t StringRef::count(StringRef Str) const {
372  size_t Count = 0;
373  size_t N = Str.size();
374  if (!N || N > Length)
375  return 0;
376  for (size_t i = 0, e = Length - N + 1; i < e;) {
377  if (substr(i, N).equals(Str)) {
378  ++Count;
379  i += N;
380  }
381  else
382  ++i;
383  }
384  return Count;
385 }
386 
387 static unsigned GetAutoSenseRadix(StringRef &Str) {
388  if (Str.empty())
389  return 10;
390 
391  if (Str.startswith("0x") || Str.startswith("0X")) {
392  Str = Str.substr(2);
393  return 16;
394  }
395 
396  if (Str.startswith("0b") || Str.startswith("0B")) {
397  Str = Str.substr(2);
398  return 2;
399  }
400 
401  if (Str.startswith("0o")) {
402  Str = Str.substr(2);
403  return 8;
404  }
405 
406  if (Str[0] == '0' && Str.size() > 1 && isDigit(Str[1])) {
407  Str = Str.substr(1);
408  return 8;
409  }
410 
411  return 10;
412 }
413 
414 bool llvm::consumeUnsignedInteger(StringRef &Str, unsigned Radix,
415  unsigned long long &Result) {
416  // Autosense radix if not specified.
417  if (Radix == 0)
418  Radix = GetAutoSenseRadix(Str);
419 
420  // Empty strings (after the radix autosense) are invalid.
421  if (Str.empty()) return true;
422 
423  // Parse all the bytes of the string given this radix. Watch for overflow.
424  StringRef Str2 = Str;
425  Result = 0;
426  while (!Str2.empty()) {
427  unsigned CharVal;
428  if (Str2[0] >= '0' && Str2[0] <= '9')
429  CharVal = Str2[0] - '0';
430  else if (Str2[0] >= 'a' && Str2[0] <= 'z')
431  CharVal = Str2[0] - 'a' + 10;
432  else if (Str2[0] >= 'A' && Str2[0] <= 'Z')
433  CharVal = Str2[0] - 'A' + 10;
434  else
435  break;
436 
437  // If the parsed value is larger than the integer radix, we cannot
438  // consume any more characters.
439  if (CharVal >= Radix)
440  break;
441 
442  // Add in this character.
443  unsigned long long PrevResult = Result;
444  Result = Result * Radix + CharVal;
445 
446  // Check for overflow by shifting back and seeing if bits were lost.
447  if (Result / Radix < PrevResult)
448  return true;
449 
450  Str2 = Str2.substr(1);
451  }
452 
453  // We consider the operation a failure if no characters were consumed
454  // successfully.
455  if (Str.size() == Str2.size())
456  return true;
457 
458  Str = Str2;
459  return false;
460 }
461 
462 bool llvm::consumeSignedInteger(StringRef &Str, unsigned Radix,
463  long long &Result) {
464  unsigned long long ULLVal;
465 
466  // Handle positive strings first.
467  if (Str.empty() || Str.front() != '-') {
468  if (consumeUnsignedInteger(Str, Radix, ULLVal) ||
469  // Check for value so large it overflows a signed value.
470  (long long)ULLVal < 0)
471  return true;
472  Result = ULLVal;
473  return false;
474  }
475 
476  // Get the positive part of the value.
477  StringRef Str2 = Str.drop_front(1);
478  if (consumeUnsignedInteger(Str2, Radix, ULLVal) ||
479  // Reject values so large they'd overflow as negative signed, but allow
480  // "-0". This negates the unsigned so that the negative isn't undefined
481  // on signed overflow.
482  (long long)-ULLVal > 0)
483  return true;
484 
485  Str = Str2;
486  Result = -ULLVal;
487  return false;
488 }
489 
490 /// GetAsUnsignedInteger - Workhorse method that converts a integer character
491 /// sequence of radix up to 36 to an unsigned long long value.
492 bool llvm::getAsUnsignedInteger(StringRef Str, unsigned Radix,
493  unsigned long long &Result) {
494  if (consumeUnsignedInteger(Str, Radix, Result))
495  return true;
496 
497  // For getAsUnsignedInteger, we require the whole string to be consumed or
498  // else we consider it a failure.
499  return !Str.empty();
500 }
501 
502 bool llvm::getAsSignedInteger(StringRef Str, unsigned Radix,
503  long long &Result) {
504  if (consumeSignedInteger(Str, Radix, Result))
505  return true;
506 
507  // For getAsSignedInteger, we require the whole string to be consumed or else
508  // we consider it a failure.
509  return !Str.empty();
510 }
511 
512 bool StringRef::getAsInteger(unsigned Radix, APInt &Result) const {
513  StringRef Str = *this;
514 
515  // Autosense radix if not specified.
516  if (Radix == 0)
517  Radix = GetAutoSenseRadix(Str);
518 
519  assert(Radix > 1 && Radix <= 36);
520 
521  // Empty strings (after the radix autosense) are invalid.
522  if (Str.empty()) return true;
523 
524  // Skip leading zeroes. This can be a significant improvement if
525  // it means we don't need > 64 bits.
526  while (!Str.empty() && Str.front() == '0')
527  Str = Str.substr(1);
528 
529  // If it was nothing but zeroes....
530  if (Str.empty()) {
531  Result = APInt(64, 0);
532  return false;
533  }
534 
535  // (Over-)estimate the required number of bits.
536  unsigned Log2Radix = 0;
537  while ((1U << Log2Radix) < Radix) Log2Radix++;
538  bool IsPowerOf2Radix = ((1U << Log2Radix) == Radix);
539 
540  unsigned BitWidth = Log2Radix * Str.size();
541  if (BitWidth < Result.getBitWidth())
542  BitWidth = Result.getBitWidth(); // don't shrink the result
543  else if (BitWidth > Result.getBitWidth())
544  Result = Result.zext(BitWidth);
545 
546  APInt RadixAP, CharAP; // unused unless !IsPowerOf2Radix
547  if (!IsPowerOf2Radix) {
548  // These must have the same bit-width as Result.
549  RadixAP = APInt(BitWidth, Radix);
550  CharAP = APInt(BitWidth, 0);
551  }
552 
553  // Parse all the bytes of the string given this radix.
554  Result = 0;
555  while (!Str.empty()) {
556  unsigned CharVal;
557  if (Str[0] >= '0' && Str[0] <= '9')
558  CharVal = Str[0]-'0';
559  else if (Str[0] >= 'a' && Str[0] <= 'z')
560  CharVal = Str[0]-'a'+10;
561  else if (Str[0] >= 'A' && Str[0] <= 'Z')
562  CharVal = Str[0]-'A'+10;
563  else
564  return true;
565 
566  // If the parsed value is larger than the integer radix, the string is
567  // invalid.
568  if (CharVal >= Radix)
569  return true;
570 
571  // Add in this character.
572  if (IsPowerOf2Radix) {
573  Result <<= Log2Radix;
574  Result |= CharVal;
575  } else {
576  Result *= RadixAP;
577  CharAP = CharVal;
578  Result += CharAP;
579  }
580 
581  Str = Str.substr(1);
582  }
583 
584  return false;
585 }
586 
587 bool StringRef::getAsDouble(double &Result, bool AllowInexact) const {
588  APFloat F(0.0);
589  auto StatusOrErr = F.convertFromString(*this, APFloat::rmNearestTiesToEven);
590  if (errorToBool(StatusOrErr.takeError()))
591  return true;
592 
593  APFloat::opStatus Status = *StatusOrErr;
594  if (Status != APFloat::opOK) {
595  if (!AllowInexact || !(Status & APFloat::opInexact))
596  return true;
597  }
598 
599  Result = F.convertToDouble();
600  return false;
601 }
602 
603 // Implementation of StringRef hashing.
605  return hash_combine_range(S.begin(), S.end());
606 }
607 
609  assert(Val.data() != getEmptyKey().data() &&
610  "Cannot hash the empty key!");
611  assert(Val.data() != getTombstoneKey().data() &&
612  "Cannot hash the tombstone key!");
613  return (unsigned)(hash_value(Val));
614 }
i
i
Definition: README.txt:29
llvm::APFloatBase::opStatus
opStatus
IEEE-754R 7: Default exception handling.
Definition: APFloat.h:206
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::StringRef::count
LLVM_NODISCARD size_t count(char C) const
Return the number of occurrences of C in the string.
Definition: StringRef.h:493
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:160
llvm::StringRef::rfind
LLVM_NODISCARD size_t rfind(char C, size_t From=npos) const
Search for the last character C in the string.
Definition: StringRef.h:379
StringRef.h
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:60
llvm::StringRef::find
LLVM_NODISCARD size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:319
memcmp
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:899
Error.h
APInt.h
llvm::StringRef::getAsDouble
bool getAsDouble(double &Result, bool AllowInexact=true) const
Parse the current string as an IEEE double-precision floating point value.
Definition: StringRef.cpp:587
Hashing.h
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::hash_value
hash_code hash_value(const APFloat &Arg)
See friend declarations above.
Definition: APFloat.cpp:4828
size_t
llvm::map_iterator
mapped_iterator< ItTy, FuncTy > map_iterator(ItTy I, FuncTy F)
Definition: STLExtras.h:322
F
#define F(x, y, z)
Definition: MD5.cpp:55
edit_distance.h
llvm::StringRef::substr
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:615
llvm::consumeSignedInteger
bool consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result)
Definition: StringRef.cpp:462
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::DenseMapInfo
An information struct used to provide DenseMap with the various necessary components for a given valu...
Definition: APInt.h:34
llvm::StringRef::find_last_of
LLVM_NODISCARD size_t find_last_of(char C, size_t From=npos) const
Find the last character in the string that is C, or npos if not found.
Definition: StringRef.h:440
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::StringRef::split
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:753
llvm::ComputeMappedEditDistance
unsigned ComputeMappedEditDistance(ArrayRef< T > FromArray, ArrayRef< T > ToArray, Functor Map, bool AllowReplacements=true, unsigned MaxEditDistance=0)
Determine the edit distance between two sequences.
Definition: edit_distance.h:46
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::StringRef::startswith_insensitive
LLVM_NODISCARD bool startswith_insensitive(StringRef Prefix) const
Check if this string starts with the given Prefix, ignoring case.
Definition: StringRef.cpp:45
llvm::getAsUnsignedInteger
bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)
Helper functions for StringRef::getAsInteger.
Definition: StringRef.cpp:492
llvm::APFloatBase::opInexact
@ opInexact
Definition: APFloat.h:212
llvm::APFloatBase::opOK
@ opOK
Definition: APFloat.h:207
APFloat.h
llvm::StringRef::getAsInteger
std::enable_if_t< std::numeric_limits< T >::is_signed, bool > getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:514
llvm::StringRef::equals
LLVM_NODISCARD bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:187
llvm::StringRef::rfind_insensitive
LLVM_NODISCARD size_t rfind_insensitive(char C, size_t From=npos) const
Search for the last character C in the string, ignoring case.
Definition: StringRef.cpp:191
llvm::APFloat
Definition: APFloat.h:701
llvm::StringRef::endswith_insensitive
LLVM_NODISCARD bool endswith_insensitive(StringRef Suffix) const
Check if this string ends with the given Suffix, ignoring case.
Definition: StringRef.cpp:50
llvm::StringRef::equals_insensitive
LLVM_NODISCARD bool equals_insensitive(StringRef RHS) const
Check for string equality, ignoring case.
Definition: StringRef.h:194
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::StringRef::upper
LLVM_NODISCARD std::string upper() const
Convert the given ASCII string to uppercase.
Definition: StringRef.cpp:117
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::StringRef::end
iterator end() const
Definition: StringRef.h:130
llvm::consumeUnsignedInteger
bool consumeUnsignedInteger(StringRef &Str, unsigned Radix, unsigned long long &Result)
Definition: StringRef.cpp:414
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
I
#define I(x, y, z)
Definition: MD5.cpp:58
ascii_strncasecmp
static int ascii_strncasecmp(const char *LHS, const char *RHS, size_t Length)
Definition: StringRef.cpp:27
StringExtras.h
llvm::StringRef::lower
LLVM_NODISCARD std::string lower() const
Definition: StringRef.cpp:112
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::StringRef::find_first_not_of
LLVM_NODISCARD size_t find_first_not_of(char C, size_t From=0) const
Find the first character in the string that is not C or npos if not found.
Definition: StringRef.cpp:248
llvm::errorToBool
bool errorToBool(Error Err)
Helper for converting an Error to a bool.
Definition: Error.h:1066
llvm::StringRef::compare_numeric
LLVM_NODISCARD int compare_numeric(StringRef RHS) const
compare_numeric - Compare two strings, treating sequences of digits as numbers.
Definition: StringRef.cpp:61
Status
Definition: SIModeRegister.cpp:29
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
isDigit
static bool isDigit(const char C)
Definition: RustDemangle.cpp:176
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
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::StringRef::size
constexpr LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::StringRef::edit_distance_insensitive
LLVM_NODISCARD unsigned edit_distance_insensitive(StringRef Other, bool AllowReplacements=true, unsigned MaxEditDistance=0) const
Definition: StringRef.cpp:101
llvm::BitWidth
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:147
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:475
This
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical This
Definition: README.txt:418
llvm::getAsSignedInteger
bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result)
Definition: StringRef.cpp:502
llvm::ComputeEditDistance
unsigned ComputeEditDistance(ArrayRef< T > FromArray, ArrayRef< T > ToArray, bool AllowReplacements=true, unsigned MaxEditDistance=0)
Definition: edit_distance.h:115
llvm::APFloatBase::rmNearestTiesToEven
static constexpr roundingMode rmNearestTiesToEven
Definition: APFloat.h:190
N
#define N
llvm::hash_combine_range
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:483
llvm::StringRef::compare_insensitive
LLVM_NODISCARD int compare_insensitive(StringRef RHS) const
Compare two strings, ignoring case.
Definition: StringRef.cpp:37
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:149
llvm::SmallVectorImpl< StringRef >
llvm::StringRef::find_insensitive
LLVM_NODISCARD size_t find_insensitive(char C, size_t From=0) const
Search for the first character C in the string, ignoring case.
Definition: StringRef.cpp:55
llvm::StringRef::find_last_not_of
LLVM_NODISCARD size_t find_last_not_of(char C, size_t From=npos) const
Find the last character in the string that is not C, or npos if not found.
Definition: StringRef.cpp:289
llvm::StringRef::find_first_of
LLVM_NODISCARD size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
Definition: StringRef.h:414
llvm::StringRef::edit_distance
LLVM_NODISCARD unsigned edit_distance(StringRef Other, bool AllowReplacements=true, unsigned MaxEditDistance=0) const
Determine the edit distance between this string and another string.
Definition: StringRef.cpp:92
GetAutoSenseRadix
static unsigned GetAutoSenseRadix(StringRef &Str)
Definition: StringRef.cpp:387
llvm::StringRef::find_if
LLVM_NODISCARD size_t find_if(function_ref< bool(char)> F, size_t From=0) const
Search for the first character satisfying the predicate F.
Definition: StringRef.h:341
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
LLVM_UNLIKELY
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:220
llvm::StringRef::begin
iterator begin() const
Definition: StringRef.h:128
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1237
llvm::hash_code
An opaque object representing a hash code.
Definition: Hashing.h:73