LLVM  16.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  if (N == 2) {
152  // Provide a fast path for newline finding (CRLF case) in InclusionRewriter.
153  // Not the most optimized strategy, but getting memcmp inlined should be
154  // good enough.
155  do {
156  if (std::memcmp(Start, Needle, 2) == 0)
157  return Start - Data;
158  ++Start;
159  } while (Start < Stop);
160  return npos;
161  }
162 
163  // For short haystacks or unsupported needles fall back to the naive algorithm
164  if (Size < 16 || N > 255) {
165  do {
166  if (std::memcmp(Start, Needle, N) == 0)
167  return Start - Data;
168  ++Start;
169  } while (Start < Stop);
170  return npos;
171  }
172 
173  // Build the bad char heuristic table, with uint8_t to reduce cache thrashing.
174  uint8_t BadCharSkip[256];
175  std::memset(BadCharSkip, N, 256);
176  for (unsigned i = 0; i != N-1; ++i)
177  BadCharSkip[(uint8_t)Str[i]] = N-1-i;
178 
179  do {
180  uint8_t Last = Start[N - 1];
181  if (LLVM_UNLIKELY(Last == (uint8_t)Needle[N - 1]))
182  if (std::memcmp(Start, Needle, N - 1) == 0)
183  return Start - Data;
184 
185  // Otherwise skip the appropriate number of bytes.
186  Start += BadCharSkip[Last];
187  } while (Start < Stop);
188 
189  return npos;
190 }
191 
192 size_t StringRef::find_insensitive(StringRef Str, size_t From) const {
194  while (This.size() >= Str.size()) {
195  if (This.startswith_insensitive(Str))
196  return From;
197  This = This.drop_front();
198  ++From;
199  }
200  return npos;
201 }
202 
203 size_t StringRef::rfind_insensitive(char C, size_t From) const {
204  From = std::min(From, Length);
205  size_t i = From;
206  while (i != 0) {
207  --i;
208  if (toLower(Data[i]) == toLower(C))
209  return i;
210  }
211  return npos;
212 }
213 
214 /// rfind - Search for the last string \arg Str in the string.
215 ///
216 /// \return - The index of the last occurrence of \arg Str, or npos if not
217 /// found.
218 size_t StringRef::rfind(StringRef Str) const {
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(Str))
225  return i;
226  }
227  return npos;
228 }
229 
231  size_t N = Str.size();
232  if (N > Length)
233  return npos;
234  for (size_t i = Length - N + 1, e = 0; i != e;) {
235  --i;
236  if (substr(i, N).equals_insensitive(Str))
237  return i;
238  }
239  return npos;
240 }
241 
242 /// find_first_of - Find the first character in the string that is in \arg
243 /// Chars, or npos if not found.
244 ///
245 /// Note: O(size() + Chars.size())
247  size_t From) const {
248  std::bitset<1 << CHAR_BIT> CharBits;
249  for (char C : Chars)
250  CharBits.set((unsigned char)C);
251 
252  for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
253  if (CharBits.test((unsigned char)Data[i]))
254  return i;
255  return npos;
256 }
257 
258 /// find_first_not_of - Find the first character in the string that is not
259 /// \arg C or npos if not found.
261  for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
262  if (Data[i] != C)
263  return i;
264  return npos;
265 }
266 
267 /// find_first_not_of - Find the first character in the string that is not
268 /// in the string \arg Chars, or npos if not found.
269 ///
270 /// Note: O(size() + Chars.size())
272  size_t From) const {
273  std::bitset<1 << CHAR_BIT> CharBits;
274  for (char C : Chars)
275  CharBits.set((unsigned char)C);
276 
277  for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
278  if (!CharBits.test((unsigned char)Data[i]))
279  return i;
280  return npos;
281 }
282 
283 /// find_last_of - Find the last character in the string that is in \arg C,
284 /// or npos if not found.
285 ///
286 /// Note: O(size() + Chars.size())
288  size_t From) const {
289  std::bitset<1 << CHAR_BIT> CharBits;
290  for (char C : Chars)
291  CharBits.set((unsigned char)C);
292 
293  for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
294  if (CharBits.test((unsigned char)Data[i]))
295  return i;
296  return npos;
297 }
298 
299 /// find_last_not_of - Find the last character in the string that is not
300 /// \arg C, or npos if not found.
302  for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
303  if (Data[i] != C)
304  return i;
305  return npos;
306 }
307 
308 /// find_last_not_of - Find the last character in the string that is not in
309 /// \arg Chars, or npos if not found.
310 ///
311 /// Note: O(size() + Chars.size())
313  size_t From) const {
314  std::bitset<1 << CHAR_BIT> CharBits;
315  for (char C : Chars)
316  CharBits.set((unsigned char)C);
317 
318  for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
319  if (!CharBits.test((unsigned char)Data[i]))
320  return i;
321  return npos;
322 }
323 
325  StringRef Separator, int MaxSplit,
326  bool KeepEmpty) const {
327  StringRef S = *this;
328 
329  // Count down from MaxSplit. When MaxSplit is -1, this will just split
330  // "forever". This doesn't support splitting more than 2^31 times
331  // intentionally; if we ever want that we can make MaxSplit a 64-bit integer
332  // but that seems unlikely to be useful.
333  while (MaxSplit-- != 0) {
334  size_t Idx = S.find(Separator);
335  if (Idx == npos)
336  break;
337 
338  // Push this split.
339  if (KeepEmpty || Idx > 0)
340  A.push_back(S.slice(0, Idx));
341 
342  // Jump forward.
343  S = S.slice(Idx + Separator.size(), npos);
344  }
345 
346  // Push the tail.
347  if (KeepEmpty || !S.empty())
348  A.push_back(S);
349 }
350 
352  int MaxSplit, bool KeepEmpty) const {
353  StringRef S = *this;
354 
355  // Count down from MaxSplit. When MaxSplit is -1, this will just split
356  // "forever". This doesn't support splitting more than 2^31 times
357  // intentionally; if we ever want that we can make MaxSplit a 64-bit integer
358  // but that seems unlikely to be useful.
359  while (MaxSplit-- != 0) {
360  size_t Idx = S.find(Separator);
361  if (Idx == npos)
362  break;
363 
364  // Push this split.
365  if (KeepEmpty || Idx > 0)
366  A.push_back(S.slice(0, Idx));
367 
368  // Jump forward.
369  S = S.slice(Idx + 1, npos);
370  }
371 
372  // Push the tail.
373  if (KeepEmpty || !S.empty())
374  A.push_back(S);
375 }
376 
377 //===----------------------------------------------------------------------===//
378 // Helpful Algorithms
379 //===----------------------------------------------------------------------===//
380 
381 /// count - Return the number of non-overlapped occurrences of \arg Str in
382 /// the string.
383 size_t StringRef::count(StringRef Str) const {
384  size_t Count = 0;
385  size_t Pos = 0;
386  size_t N = Str.size();
387  // TODO: For an empty `Str` we return 0 for legacy reasons. Consider changing
388  // this to `Length + 1` which is more in-line with the function
389  // description.
390  if (!N)
391  return 0;
392  while ((Pos = find(Str, Pos)) != npos) {
393  ++Count;
394  Pos += N;
395  }
396  return Count;
397 }
398 
399 static unsigned GetAutoSenseRadix(StringRef &Str) {
400  if (Str.empty())
401  return 10;
402 
403  if (Str.startswith("0x") || Str.startswith("0X")) {
404  Str = Str.substr(2);
405  return 16;
406  }
407 
408  if (Str.startswith("0b") || Str.startswith("0B")) {
409  Str = Str.substr(2);
410  return 2;
411  }
412 
413  if (Str.startswith("0o")) {
414  Str = Str.substr(2);
415  return 8;
416  }
417 
418  if (Str[0] == '0' && Str.size() > 1 && isDigit(Str[1])) {
419  Str = Str.substr(1);
420  return 8;
421  }
422 
423  return 10;
424 }
425 
426 bool llvm::consumeUnsignedInteger(StringRef &Str, unsigned Radix,
427  unsigned long long &Result) {
428  // Autosense radix if not specified.
429  if (Radix == 0)
430  Radix = GetAutoSenseRadix(Str);
431 
432  // Empty strings (after the radix autosense) are invalid.
433  if (Str.empty()) return true;
434 
435  // Parse all the bytes of the string given this radix. Watch for overflow.
436  StringRef Str2 = Str;
437  Result = 0;
438  while (!Str2.empty()) {
439  unsigned CharVal;
440  if (Str2[0] >= '0' && Str2[0] <= '9')
441  CharVal = Str2[0] - '0';
442  else if (Str2[0] >= 'a' && Str2[0] <= 'z')
443  CharVal = Str2[0] - 'a' + 10;
444  else if (Str2[0] >= 'A' && Str2[0] <= 'Z')
445  CharVal = Str2[0] - 'A' + 10;
446  else
447  break;
448 
449  // If the parsed value is larger than the integer radix, we cannot
450  // consume any more characters.
451  if (CharVal >= Radix)
452  break;
453 
454  // Add in this character.
455  unsigned long long PrevResult = Result;
456  Result = Result * Radix + CharVal;
457 
458  // Check for overflow by shifting back and seeing if bits were lost.
459  if (Result / Radix < PrevResult)
460  return true;
461 
462  Str2 = Str2.substr(1);
463  }
464 
465  // We consider the operation a failure if no characters were consumed
466  // successfully.
467  if (Str.size() == Str2.size())
468  return true;
469 
470  Str = Str2;
471  return false;
472 }
473 
474 bool llvm::consumeSignedInteger(StringRef &Str, unsigned Radix,
475  long long &Result) {
476  unsigned long long ULLVal;
477 
478  // Handle positive strings first.
479  if (Str.empty() || Str.front() != '-') {
480  if (consumeUnsignedInteger(Str, Radix, ULLVal) ||
481  // Check for value so large it overflows a signed value.
482  (long long)ULLVal < 0)
483  return true;
484  Result = ULLVal;
485  return false;
486  }
487 
488  // Get the positive part of the value.
489  StringRef Str2 = Str.drop_front(1);
490  if (consumeUnsignedInteger(Str2, Radix, ULLVal) ||
491  // Reject values so large they'd overflow as negative signed, but allow
492  // "-0". This negates the unsigned so that the negative isn't undefined
493  // on signed overflow.
494  (long long)-ULLVal > 0)
495  return true;
496 
497  Str = Str2;
498  Result = -ULLVal;
499  return false;
500 }
501 
502 /// GetAsUnsignedInteger - Workhorse method that converts a integer character
503 /// sequence of radix up to 36 to an unsigned long long value.
504 bool llvm::getAsUnsignedInteger(StringRef Str, unsigned Radix,
505  unsigned long long &Result) {
506  if (consumeUnsignedInteger(Str, Radix, Result))
507  return true;
508 
509  // For getAsUnsignedInteger, we require the whole string to be consumed or
510  // else we consider it a failure.
511  return !Str.empty();
512 }
513 
514 bool llvm::getAsSignedInteger(StringRef Str, unsigned Radix,
515  long long &Result) {
516  if (consumeSignedInteger(Str, Radix, Result))
517  return true;
518 
519  // For getAsSignedInteger, we require the whole string to be consumed or else
520  // we consider it a failure.
521  return !Str.empty();
522 }
523 
524 bool StringRef::getAsInteger(unsigned Radix, APInt &Result) const {
525  StringRef Str = *this;
526 
527  // Autosense radix if not specified.
528  if (Radix == 0)
529  Radix = GetAutoSenseRadix(Str);
530 
531  assert(Radix > 1 && Radix <= 36);
532 
533  // Empty strings (after the radix autosense) are invalid.
534  if (Str.empty()) return true;
535 
536  // Skip leading zeroes. This can be a significant improvement if
537  // it means we don't need > 64 bits.
538  while (!Str.empty() && Str.front() == '0')
539  Str = Str.substr(1);
540 
541  // If it was nothing but zeroes....
542  if (Str.empty()) {
543  Result = APInt(64, 0);
544  return false;
545  }
546 
547  // (Over-)estimate the required number of bits.
548  unsigned Log2Radix = 0;
549  while ((1U << Log2Radix) < Radix) Log2Radix++;
550  bool IsPowerOf2Radix = ((1U << Log2Radix) == Radix);
551 
552  unsigned BitWidth = Log2Radix * Str.size();
553  if (BitWidth < Result.getBitWidth())
554  BitWidth = Result.getBitWidth(); // don't shrink the result
555  else if (BitWidth > Result.getBitWidth())
556  Result = Result.zext(BitWidth);
557 
558  APInt RadixAP, CharAP; // unused unless !IsPowerOf2Radix
559  if (!IsPowerOf2Radix) {
560  // These must have the same bit-width as Result.
561  RadixAP = APInt(BitWidth, Radix);
562  CharAP = APInt(BitWidth, 0);
563  }
564 
565  // Parse all the bytes of the string given this radix.
566  Result = 0;
567  while (!Str.empty()) {
568  unsigned CharVal;
569  if (Str[0] >= '0' && Str[0] <= '9')
570  CharVal = Str[0]-'0';
571  else if (Str[0] >= 'a' && Str[0] <= 'z')
572  CharVal = Str[0]-'a'+10;
573  else if (Str[0] >= 'A' && Str[0] <= 'Z')
574  CharVal = Str[0]-'A'+10;
575  else
576  return true;
577 
578  // If the parsed value is larger than the integer radix, the string is
579  // invalid.
580  if (CharVal >= Radix)
581  return true;
582 
583  // Add in this character.
584  if (IsPowerOf2Radix) {
585  Result <<= Log2Radix;
586  Result |= CharVal;
587  } else {
588  Result *= RadixAP;
589  CharAP = CharVal;
590  Result += CharAP;
591  }
592 
593  Str = Str.substr(1);
594  }
595 
596  return false;
597 }
598 
599 bool StringRef::getAsDouble(double &Result, bool AllowInexact) const {
600  APFloat F(0.0);
601  auto StatusOrErr = F.convertFromString(*this, APFloat::rmNearestTiesToEven);
602  if (errorToBool(StatusOrErr.takeError()))
603  return true;
604 
605  APFloat::opStatus Status = *StatusOrErr;
606  if (Status != APFloat::opOK) {
607  if (!AllowInexact || !(Status & APFloat::opInexact))
608  return true;
609  }
610 
611  Result = F.convertToDouble();
612  return false;
613 }
614 
615 // Implementation of StringRef hashing.
617  return hash_combine_range(S.begin(), S.end());
618 }
619 
621  assert(Val.data() != getEmptyKey().data() &&
622  "Cannot hash the empty key!");
623  assert(Val.data() != getTombstoneKey().data() &&
624  "Cannot hash the tombstone key!");
625  return (unsigned)(hash_value(Val));
626 }
i
i
Definition: README.txt:29
llvm::APFloatBase::opStatus
opStatus
IEEE-754R 7: Default exception handling.
Definition: APFloat.h:216
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::StringRef::rfind
size_t rfind(char C, size_t From=npos) const
Search for the last character C in the string.
Definition: StringRef.h:350
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:161
llvm::PseudoProbeReservedId::Last
@ Last
StringRef.h
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:52
memcmp
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:903
Error.h
APInt.h
llvm::StringRef::find_first_of
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:381
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:599
llvm::StringRef::substr
StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:564
Hashing.h
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
size_t
llvm::map_iterator
mapped_iterator< ItTy, FuncTy > map_iterator(ItTy I, FuncTy F)
Definition: STLExtras.h:430
F
#define F(x, y, z)
Definition: MD5.cpp:55
edit_distance.h
llvm::consumeSignedInteger
bool consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result)
Definition: StringRef.cpp:474
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
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
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::getAsUnsignedInteger
bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)
Helper functions for StringRef::getAsInteger.
Definition: StringRef.cpp:504
llvm::APFloatBase::opInexact
@ opInexact
Definition: APFloat.h:222
llvm::StringRef::getAsInteger
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:474
llvm::APFloatBase::opOK
@ opOK
Definition: APFloat.h:217
APFloat.h
llvm::StringRef::data
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
llvm::StringRef::equals
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:164
llvm::StringRef::empty
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
llvm::StringRef::rfind_insensitive
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:203
llvm::APFloat
Definition: APFloat.h:716
llvm::StringRef::upper
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:113
llvm::consumeUnsignedInteger
bool consumeUnsignedInteger(StringRef &Str, unsigned Radix, unsigned long long &Result)
Definition: StringRef.cpp:426
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:53
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
std::string lower() const
Definition: StringRef.cpp:112
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Ptr
@ Ptr
Definition: TargetLibraryInfo.cpp:60
llvm::StringRef::find_first_not_of
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:260
llvm::errorToBool
bool errorToBool(Error Err)
Helper for converting an Error to a bool.
Definition: Error.h:1065
llvm::StringRef::compare_numeric
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:173
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:50
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::find_last_of
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:404
llvm::StringRef::count
size_t count(char C) const
Return the number of occurrences of C in the string.
Definition: StringRef.h:455
llvm::StringRef::size
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
llvm::StringRef::starts_with_insensitive
bool starts_with_insensitive(StringRef Prefix) const
Check if this string starts with the given Prefix, ignoring case.
Definition: StringRef.cpp:45
llvm::StringRef::edit_distance_insensitive
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::StringRef::find_if
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:314
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:475
llvm::hash_value
hash_code hash_value(const FixedPointSemantics &Val)
Definition: APFixedPoint.h:127
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:514
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:200
llvm::StringRef::equals_insensitive
bool equals_insensitive(StringRef RHS) const
Check for string equality, ignoring case.
Definition: StringRef.h:170
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
int compare_insensitive(StringRef RHS) const
Compare two strings, ignoring case.
Definition: StringRef.cpp:37
llvm::SmallVectorImpl< StringRef >
llvm::StringRef::find_insensitive
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
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:294
llvm::StringRef::find_last_not_of
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:301
llvm::StringRef::edit_distance
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:399
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
LLVM_UNLIKELY
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:210
llvm::StringRef::ends_with_insensitive
bool ends_with_insensitive(StringRef Suffix) const
Check if this string ends with the given Suffix, ignoring case.
Definition: StringRef.cpp:50
llvm::StringRef::begin
iterator begin() const
Definition: StringRef.h:111
llvm::StringRef::split
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:692
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1251
llvm::hash_code
An opaque object representing a hash code.
Definition: Hashing.h:73