LCOV - code coverage report
Current view: top level - lib/Support - StringRef.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 238 239 99.6 %
Date: 2018-07-13 00:08:38 Functions: 30 30 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- StringRef.cpp - Lightweight String References ---------------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : 
      10             : #include "llvm/ADT/StringRef.h"
      11             : #include "llvm/ADT/APFloat.h"
      12             : #include "llvm/ADT/APInt.h"
      13             : #include "llvm/ADT/Hashing.h"
      14             : #include "llvm/ADT/StringExtras.h"
      15             : #include "llvm/ADT/edit_distance.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             : const 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    69650806 :   for (size_t I = 0; I < Length; ++I) {
      29    87376103 :     unsigned char LHC = toLower(LHS[I]);
      30    87376103 :     unsigned char RHC = toLower(RHS[I]);
      31    43864341 :     if (LHC != RHC)
      32    18370317 :       return LHC < RHC ? -1 : 1;
      33             :   }
      34             :   return 0;
      35             : }
      36             : 
      37             : /// compare_lower - Compare strings, ignoring case.
      38    18946536 : int StringRef::compare_lower(StringRef RHS) const {
      39    37893072 :   if (int Res = ascii_strncasecmp(Data, RHS.Data, std::min(Length, RHS.Length)))
      40             :     return Res;
      41      576219 :   if (Length == RHS.Length)
      42             :     return 0;
      43        4781 :   return Length < RHS.Length ? -1 : 1;
      44             : }
      45             : 
      46             : /// Check if this string starts with the given \p Prefix, ignoring case.
      47      305592 : bool StringRef::startswith_lower(StringRef Prefix) const {
      48      305592 :   return Length >= Prefix.Length &&
      49      598805 :       ascii_strncasecmp(Data, Prefix.Data, Prefix.Length) == 0;
      50             : }
      51             : 
      52             : /// Check if this string ends with the given \p Suffix, ignoring case.
      53       19224 : bool StringRef::endswith_lower(StringRef Suffix) const {
      54       19224 :   return Length >= Suffix.Length &&
      55       36305 :       ascii_strncasecmp(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
      56             : }
      57             : 
      58          14 : size_t StringRef::find_lower(char C, size_t From) const {
      59             :   char L = toLower(C);
      60          78 :   return find_if([L](char D) { return toLower(D) == L; }, From);
      61             : }
      62             : 
      63             : /// compare_numeric - Compare strings, handle embedded numbers.
      64      727558 : int StringRef::compare_numeric(StringRef RHS) const {
      65     7224275 :   for (size_t I = 0, E = std::min(Length, RHS.Length); I != E; ++I) {
      66             :     // Check for sequences of digits.
      67    13515260 :     if (isDigit(Data[I]) && isDigit(RHS.Data[I])) {
      68             :       // The longer sequence of numbers is considered larger.
      69             :       // This doesn't really handle prefixed zeros well.
      70             :       size_t J;
      71     3913418 :       for (J = I + 1; J != E + 1; ++J) {
      72     3460707 :         bool ld = J < Length && isDigit(Data[J]);
      73     3462795 :         bool rd = J < RHS.Length && isDigit(RHS.Data[J]);
      74     1956709 :         if (ld != rd)
      75       13099 :           return rd ? -1 : 1;
      76     1943610 :         if (!rd)
      77             :           break;
      78             :       }
      79             :       // The two number sequences have the same length (J-I), just memcmp them.
      80     1032946 :       if (int Res = compareMemory(Data + I, RHS.Data + I, J - I))
      81      468507 :         return Res < 0 ? -1 : 1;
      82             :       // Identical number sequences, continue search after the numbers.
      83       47966 :       I = J - 1;
      84       47966 :       continue;
      85             :     }
      86     5961579 :     if (Data[I] != RHS.Data[I])
      87      240386 :       return (unsigned char)Data[I] < (unsigned char)RHS.Data[I] ? -1 : 1;
      88             :   }
      89        5566 :   if (Length == RHS.Length)
      90             :     return 0;
      91        4262 :   return Length < RHS.Length ? -1 : 1;
      92             : }
      93             : 
      94             : // Compute the edit distance between the two given strings.
      95     1651501 : unsigned StringRef::edit_distance(llvm::StringRef Other,
      96             :                                   bool AllowReplacements,
      97             :                                   unsigned MaxEditDistance) const {
      98     1651501 :   return llvm::ComputeEditDistance(
      99             :       makeArrayRef(data(), size()),
     100             :       makeArrayRef(Other.data(), Other.size()),
     101     1651501 :       AllowReplacements, MaxEditDistance);
     102             : }
     103             : 
     104             : //===----------------------------------------------------------------------===//
     105             : // String Operations
     106             : //===----------------------------------------------------------------------===//
     107             : 
     108     6435570 : std::string StringRef::lower() const {
     109             :   std::string Result(size(), char());
     110   176868926 :   for (size_type i = 0, e = size(); i != e; ++i) {
     111   170433356 :     Result[i] = toLower(Data[i]);
     112             :   }
     113     6435570 :   return Result;
     114             : }
     115             : 
     116      487916 : std::string StringRef::upper() const {
     117             :   std::string Result(size(), char());
     118     4085076 :   for (size_type i = 0, e = size(); i != e; ++i) {
     119     3597160 :     Result[i] = toUpper(Data[i]);
     120             :   }
     121      487916 :   return Result;
     122             : }
     123             : 
     124             : //===----------------------------------------------------------------------===//
     125             : // String Searching
     126             : //===----------------------------------------------------------------------===//
     127             : 
     128             : 
     129             : /// find - Search for the first string \arg Str in the string.
     130             : ///
     131             : /// \return - The index of the first occurrence of \arg Str, or npos if not
     132             : /// found.
     133    40547520 : size_t StringRef::find(StringRef Str, size_t From) const {
     134    40547520 :   if (From > Length)
     135             :     return npos;
     136             : 
     137    40547521 :   const char *Start = Data + From;
     138    40547521 :   size_t Size = Length - From;
     139             : 
     140             :   const char *Needle = Str.data();
     141             :   size_t N = Str.size();
     142    40547521 :   if (N == 0)
     143             :     return From;
     144    40546908 :   if (Size < N)
     145             :     return npos;
     146    39682411 :   if (N == 1) {
     147    27776850 :     const char *Ptr = (const char *)::memchr(Start, Needle[0], Size);
     148    27776850 :     return Ptr == nullptr ? npos : Ptr - Data;
     149             :   }
     150             : 
     151    11905561 :   const char *Stop = Start + (Size - N + 1);
     152             : 
     153             :   // For short haystacks or unsupported needles fall back to the naive algorithm
     154    11905561 :   if (Size < 16 || N > 255) {
     155             :     do {
     156    20322992 :       if (std::memcmp(Start, Needle, N) == 0)
     157      261629 :         return Start - Data;
     158    20061363 :       ++Start;
     159    20061363 :     } while (Start < Stop);
     160             :     return npos;
     161             :   }
     162             : 
     163             :   // Build the bad char heuristic table, with uint8_t to reduce cache thrashing.
     164             :   uint8_t BadCharSkip[256];
     165     9025687 :   std::memset(BadCharSkip, N, 256);
     166   164300165 :   for (unsigned i = 0; i != N-1; ++i)
     167   155274478 :     BadCharSkip[(uint8_t)Str[i]] = N-1-i;
     168             : 
     169             :   do {
     170   161715297 :     uint8_t Last = Start[N - 1];
     171   161715297 :     if (LLVM_UNLIKELY(Last == (uint8_t)Needle[N - 1]))
     172     8445456 :       if (std::memcmp(Start, Needle, N - 1) == 0)
     173     4493587 :         return Start - Data;
     174             : 
     175             :     // Otherwise skip the appropriate number of bytes.
     176   157221710 :     Start += BadCharSkip[Last];
     177   157221710 :   } while (Start < Stop);
     178             : 
     179             :   return npos;
     180             : }
     181             : 
     182        5935 : size_t StringRef::find_lower(StringRef Str, size_t From) const {
     183        5935 :   StringRef This = substr(From);
     184      345967 :   while (This.size() >= Str.size()) {
     185      170466 :     if (This.startswith_lower(Str))
     186             :       return From;
     187      170016 :     This = This.drop_front();
     188      170016 :     ++From;
     189             :   }
     190             :   return npos;
     191             : }
     192             : 
     193           3 : size_t StringRef::rfind_lower(char C, size_t From) const {
     194           6 :   From = std::min(From, Length);
     195             :   size_t i = From;
     196          15 :   while (i != 0) {
     197          14 :     --i;
     198          28 :     if (toLower(Data[i]) == toLower(C))
     199             :       return i;
     200             :   }
     201             :   return npos;
     202             : }
     203             : 
     204             : /// rfind - Search for the last string \arg Str in the string.
     205             : ///
     206             : /// \return - The index of the last occurrence of \arg Str, or npos if not
     207             : /// found.
     208      328984 : size_t StringRef::rfind(StringRef Str) const {
     209             :   size_t N = Str.size();
     210      328984 :   if (N > Length)
     211             :     return npos;
     212      328953 :   for (size_t i = Length - N + 1, e = 0; i != e;) {
     213     2703082 :     --i;
     214             :     if (substr(i, N).equals(Str))
     215             :       return i;
     216             :   }
     217             :   return npos;
     218             : }
     219             : 
     220           1 : size_t StringRef::rfind_lower(StringRef Str) const {
     221             :   size_t N = Str.size();
     222           1 :   if (N > Length)
     223             :     return npos;
     224           1 :   for (size_t i = Length - N + 1, e = 0; i != e;) {
     225           1 :     --i;
     226           2 :     if (substr(i, N).equals_lower(Str))
     227           0 :       return i;
     228             :   }
     229             :   return npos;
     230             : }
     231             : 
     232             : /// find_first_of - Find the first character in the string that is in \arg
     233             : /// Chars, or npos if not found.
     234             : ///
     235             : /// Note: O(size() + Chars.size())
     236    30528594 : StringRef::size_type StringRef::find_first_of(StringRef Chars,
     237             :                                               size_t From) const {
     238    30528594 :   std::bitset<1 << CHAR_BIT> CharBits;
     239   142815030 :   for (size_type i = 0; i != Chars.size(); ++i)
     240    56148424 :     CharBits.set((unsigned char)Chars[i]);
     241             : 
     242   341199767 :   for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
     243   297577278 :     if (CharBits.test((unsigned char)Data[i]))
     244             :       return i;
     245             :   return npos;
     246             : }
     247             : 
     248             : /// find_first_not_of - Find the first character in the string that is not
     249             : /// \arg C or npos if not found.
     250       15751 : StringRef::size_type StringRef::find_first_not_of(char C, size_t From) const {
     251       32767 :   for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
     252       15556 :     if (Data[i] != C)
     253             :       return i;
     254             :   return npos;
     255             : }
     256             : 
     257             : /// find_first_not_of - Find the first character in the string that is not
     258             : /// in the string \arg Chars, or npos if not found.
     259             : ///
     260             : /// Note: O(size() + Chars.size())
     261    34815567 : StringRef::size_type StringRef::find_first_not_of(StringRef Chars,
     262             :                                                   size_t From) const {
     263    34815567 :   std::bitset<1 << CHAR_BIT> CharBits;
     264   403811715 :   for (size_type i = 0; i != Chars.size(); ++i)
     265   368996082 :     CharBits.set((unsigned char)Chars[i]);
     266             : 
     267    78697098 :   for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
     268    42494660 :     if (!CharBits.test((unsigned char)Data[i]))
     269             :       return i;
     270             :   return npos;
     271             : }
     272             : 
     273             : /// find_last_of - Find the last character in the string that is in \arg C,
     274             : /// or npos if not found.
     275             : ///
     276             : /// Note: O(size() + Chars.size())
     277     5650166 : StringRef::size_type StringRef::find_last_of(StringRef Chars,
     278             :                                              size_t From) const {
     279     5650166 :   std::bitset<1 << CHAR_BIT> CharBits;
     280    17093462 :   for (size_type i = 0; i != Chars.size(); ++i)
     281    11443292 :     CharBits.set((unsigned char)Chars[i]);
     282             : 
     283    48333887 :   for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
     284    41775517 :     if (CharBits.test((unsigned char)Data[i]))
     285             :       return i;
     286             :   return npos;
     287             : }
     288             : 
     289             : /// find_last_not_of - Find the last character in the string that is not
     290             : /// \arg C, or npos if not found.
     291      306328 : StringRef::size_type StringRef::find_last_not_of(char C, size_t From) const {
     292      630475 :   for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
     293      322691 :     if (Data[i] != C)
     294             :       return i;
     295             :   return npos;
     296             : }
     297             : 
     298             : /// find_last_not_of - Find the last character in the string that is not in
     299             : /// \arg Chars, or npos if not found.
     300             : ///
     301             : /// Note: O(size() + Chars.size())
     302    25742179 : StringRef::size_type StringRef::find_last_not_of(StringRef Chars,
     303             :                                                  size_t From) const {
     304    25742179 :   std::bitset<1 << CHAR_BIT> CharBits;
     305   332904489 :   for (size_type i = 0, e = Chars.size(); i != e; ++i)
     306   307162310 :     CharBits.set((unsigned char)Chars[i]);
     307             : 
     308    53919897 :   for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
     309    27729772 :     if (!CharBits.test((unsigned char)Data[i]))
     310             :       return i;
     311             :   return npos;
     312             : }
     313             : 
     314      736382 : void StringRef::split(SmallVectorImpl<StringRef> &A,
     315             :                       StringRef Separator, int MaxSplit,
     316             :                       bool KeepEmpty) const {
     317      736382 :   StringRef S = *this;
     318             : 
     319             :   // Count down from MaxSplit. When MaxSplit is -1, this will just split
     320             :   // "forever". This doesn't support splitting more than 2^31 times
     321             :   // intentionally; if we ever want that we can make MaxSplit a 64-bit integer
     322             :   // but that seems unlikely to be useful.
     323    44042888 :   while (MaxSplit-- != 0) {
     324    22389622 :     size_t Idx = S.find(Separator);
     325    22389622 :     if (Idx == npos)
     326             :       break;
     327             : 
     328             :     // Push this split.
     329    21653253 :     if (KeepEmpty || Idx > 0)
     330    41708348 :       A.push_back(S.slice(0, Idx));
     331             : 
     332             :     // Jump forward.
     333    43306506 :     S = S.slice(Idx + Separator.size(), npos);
     334             :   }
     335             : 
     336             :   // Push the tail.
     337      850634 :   if (KeepEmpty || !S.empty())
     338      630519 :     A.push_back(S);
     339      736382 : }
     340             : 
     341     1660439 : void StringRef::split(SmallVectorImpl<StringRef> &A, char Separator,
     342             :                       int MaxSplit, bool KeepEmpty) const {
     343     1660439 :   StringRef S = *this;
     344             : 
     345             :   // Count down from MaxSplit. When MaxSplit is -1, this will just split
     346             :   // "forever". This doesn't support splitting more than 2^31 times
     347             :   // intentionally; if we ever want that we can make MaxSplit a 64-bit integer
     348             :   // but that seems unlikely to be useful.
     349     8499147 :   while (MaxSplit-- != 0) {
     350     4454543 :     size_t Idx = S.find(Separator);
     351     3419354 :     if (Idx == npos)
     352             :       break;
     353             : 
     354             :     // Push this split.
     355     3419354 :     if (KeepEmpty || Idx > 0)
     356     6838696 :       A.push_back(S.slice(0, Idx));
     357             : 
     358             :     // Jump forward.
     359     6838708 :     S = S.slice(Idx + 1, npos);
     360             :   }
     361             : 
     362             :   // Push the tail.
     363     1816492 :   if (KeepEmpty || !S.empty())
     364     1589592 :     A.push_back(S);
     365     1660436 : }
     366             : 
     367             : //===----------------------------------------------------------------------===//
     368             : // Helpful Algorithms
     369             : //===----------------------------------------------------------------------===//
     370             : 
     371             : /// count - Return the number of non-overlapped occurrences of \arg Str in
     372             : /// the string.
     373        6616 : size_t StringRef::count(StringRef Str) const {
     374             :   size_t Count = 0;
     375             :   size_t N = Str.size();
     376        6616 :   if (N > Length)
     377             :     return 0;
     378      116375 :   for (size_t i = 0, e = Length - N + 1; i != e; ++i)
     379             :     if (substr(i, N).equals(Str))
     380       50261 :       ++Count;
     381             :   return Count;
     382             : }
     383             : 
     384     1105633 : static unsigned GetAutoSenseRadix(StringRef &Str) {
     385     1105633 :   if (Str.empty())
     386             :     return 10;
     387             : 
     388             :   if (Str.startswith("0x") || Str.startswith("0X")) {
     389      828419 :     Str = Str.substr(2);
     390      828419 :     return 16;
     391             :   }
     392             :   
     393             :   if (Str.startswith("0b") || Str.startswith("0B")) {
     394          38 :     Str = Str.substr(2);
     395          38 :     return 2;
     396             :   }
     397             : 
     398             :   if (Str.startswith("0o")) {
     399           1 :     Str = Str.substr(2);
     400           1 :     return 8;
     401             :   }
     402             : 
     403      561010 :   if (Str[0] == '0' && Str.size() > 1 && isDigit(Str[1])) {
     404          44 :     Str = Str.substr(1);
     405          44 :     return 8;
     406             :   }
     407             : 
     408             :   return 10;
     409             : }
     410             : 
     411     5643385 : bool llvm::consumeUnsignedInteger(StringRef &Str, unsigned Radix,
     412             :                                   unsigned long long &Result) {
     413             :   // Autosense radix if not specified.
     414     5643385 :   if (Radix == 0)
     415     1058570 :     Radix = GetAutoSenseRadix(Str);
     416             : 
     417             :   // Empty strings (after the radix autosense) are invalid.
     418     5643385 :   if (Str.empty()) return true;
     419             : 
     420             :   // Parse all the bytes of the string given this radix.  Watch for overflow.
     421     5630275 :   StringRef Str2 = Str;
     422     5630275 :   Result = 0;
     423    22603875 :   while (!Str2.empty()) {
     424             :     unsigned CharVal;
     425    17209968 :     if (Str2[0] >= '0' && Str2[0] <= '9')
     426     8082549 :       CharVal = Str2[0] - '0';
     427      522435 :     else if (Str2[0] >= 'a' && Str2[0] <= 'z')
     428      487878 :       CharVal = Str2[0] - 'a' + 10;
     429       56535 :     else if (Str2[0] >= 'A' && Str2[0] <= 'Z')
     430       19758 :       CharVal = Str2[0] - 'A' + 10;
     431             :     else
     432             :       break;
     433             : 
     434             :     // If the parsed value is larger than the integer radix, we cannot
     435             :     // consume any more characters.
     436     8590185 :     if (CharVal >= Radix)
     437             :       break;
     438             : 
     439             :     // Add in this character.
     440     8486805 :     unsigned long long PrevResult = Result;
     441     8486805 :     Result = Result * Radix + CharVal;
     442             : 
     443             :     // Check for overflow by shifting back and seeing if bits were lost.
     444     8486805 :     if (Result / Radix < PrevResult)
     445             :       return true;
     446             : 
     447     8486800 :     Str2 = Str2.substr(1);
     448             :   }
     449             : 
     450             :   // We consider the operation a failure if no characters were consumed
     451             :   // successfully.
     452     5630270 :   if (Str.size() == Str2.size())
     453             :     return true;
     454             : 
     455     5525441 :   Str = Str2;
     456     5525441 :   return false;
     457             : }
     458             : 
     459     2333149 : bool llvm::consumeSignedInteger(StringRef &Str, unsigned Radix,
     460             :                                 long long &Result) {
     461             :   unsigned long long ULLVal;
     462             : 
     463             :   // Handle positive strings first.
     464     4666264 :   if (Str.empty() || Str.front() != '-') {
     465     4607319 :     if (consumeUnsignedInteger(Str, Radix, ULLVal) ||
     466             :         // Check for value so large it overflows a signed value.
     467     2287944 :         (long long)ULLVal < 0)
     468             :       return true;
     469     2287943 :     Result = ULLVal;
     470     2287943 :     return false;
     471             :   }
     472             : 
     473             :   // Get the positive part of the value.
     474       13774 :   StringRef Str2 = Str.drop_front(1);
     475       27548 :   if (consumeUnsignedInteger(Str2, Radix, ULLVal) ||
     476             :       // Reject values so large they'd overflow as negative signed, but allow
     477             :       // "-0".  This negates the unsigned so that the negative isn't undefined
     478             :       // on signed overflow.
     479       13774 :       (long long)-ULLVal > 0)
     480             :     return true;
     481             : 
     482       13773 :   Str = Str2;
     483       13773 :   Result = -ULLVal;
     484       13773 :   return false;
     485             : }
     486             : 
     487             : /// GetAsUnsignedInteger - Workhorse method that converts a integer character
     488             : /// sequence of radix up to 36 to an unsigned long long value.
     489     3143173 : bool llvm::getAsUnsignedInteger(StringRef Str, unsigned Radix,
     490             :                                 unsigned long long &Result) {
     491     3143173 :   if (consumeUnsignedInteger(Str, Radix, Result))
     492             :     return true;
     493             : 
     494             :   // For getAsUnsignedInteger, we require the whole string to be consumed or
     495             :   // else we consider it a failure.
     496     3068997 :   return !Str.empty();
     497             : }
     498             : 
     499     2331970 : bool llvm::getAsSignedInteger(StringRef Str, unsigned Radix,
     500             :                               long long &Result) {
     501     2331970 :   if (consumeSignedInteger(Str, Radix, Result))
     502             :     return true;
     503             : 
     504             :   // For getAsSignedInteger, we require the whole string to be consumed or else
     505             :   // we consider it a failure.
     506     2300541 :   return !Str.empty();
     507             : }
     508             : 
     509      631294 : bool StringRef::getAsInteger(unsigned Radix, APInt &Result) const {
     510      631294 :   StringRef Str = *this;
     511             : 
     512             :   // Autosense radix if not specified.
     513      631294 :   if (Radix == 0)
     514       47063 :     Radix = GetAutoSenseRadix(Str);
     515             : 
     516             :   assert(Radix > 1 && Radix <= 36);
     517             : 
     518             :   // Empty strings (after the radix autosense) are invalid.
     519      631294 :   if (Str.empty()) return true;
     520             : 
     521             :   // Skip leading zeroes.  This can be a significant improvement if
     522             :   // it means we don't need > 64 bits.
     523     1429145 :   while (!Str.empty() && Str.front() == '0')
     524       79468 :     Str = Str.substr(1);
     525             : 
     526             :   // If it was nothing but zeroes....
     527      631294 :   if (Str.empty()) {
     528       71847 :     Result = APInt(64, 0);
     529       71847 :     return false;
     530             :   }
     531             : 
     532             :   // (Over-)estimate the required number of bits.
     533             :   unsigned Log2Radix = 0;
     534     2797103 :   while ((1U << Log2Radix) < Radix) Log2Radix++;
     535             :   bool IsPowerOf2Radix = ((1U << Log2Radix) == Radix);
     536             : 
     537      559447 :   unsigned BitWidth = Log2Radix * Str.size();
     538      559447 :   if (BitWidth < Result.getBitWidth())
     539             :     BitWidth = Result.getBitWidth(); // don't shrink the result
     540          48 :   else if (BitWidth > Result.getBitWidth())
     541          82 :     Result = Result.zext(BitWidth);
     542             : 
     543             :   APInt RadixAP, CharAP; // unused unless !IsPowerOf2Radix
     544      559447 :   if (!IsPowerOf2Radix) {
     545             :     // These must have the same bit-width as Result.
     546     1058098 :     RadixAP = APInt(BitWidth, Radix);
     547      529049 :     CharAP = APInt(BitWidth, 0);
     548             :   }
     549             : 
     550             :   // Parse all the bytes of the string given this radix.
     551      559447 :   Result = 0;
     552     2732549 :   while (!Str.empty()) {
     553             :     unsigned CharVal;
     554     2173140 :     if (Str[0] >= '0' && Str[0] <= '9')
     555     1042997 :       CharVal = Str[0]-'0';
     556       84401 :     else if (Str[0] >= 'a' && Str[0] <= 'z')
     557       40828 :       CharVal = Str[0]-'a'+10;
     558        5490 :     else if (Str[0] >= 'A' && Str[0] <= 'Z')
     559        2745 :       CharVal = Str[0]-'A'+10;
     560             :     else
     561             :       return true;
     562             : 
     563             :     // If the parsed value is larger than the integer radix, the string is
     564             :     // invalid.
     565     1086570 :     if (CharVal >= Radix)
     566             :       return true;
     567             : 
     568             :     // Add in this character.
     569     1086551 :     if (IsPowerOf2Radix) {
     570      125349 :       Result <<= Log2Radix;
     571      125349 :       Result |= CharVal;
     572             :     } else {
     573      961202 :       Result *= RadixAP;
     574      961202 :       CharAP = CharVal;
     575      961202 :       Result += CharAP;
     576             :     }
     577             : 
     578     1086551 :     Str = Str.substr(1);
     579             :   }
     580             : 
     581             :   return false;
     582             : }
     583             : 
     584          11 : bool StringRef::getAsDouble(double &Result, bool AllowInexact) const {
     585          11 :   APFloat F(0.0);
     586             :   APFloat::opStatus Status =
     587          11 :       F.convertFromString(*this, APFloat::rmNearestTiesToEven);
     588          11 :   if (Status != APFloat::opOK) {
     589           6 :     if (!AllowInexact || !(Status & APFloat::opInexact))
     590             :       return true;
     591             :   }
     592             : 
     593           8 :   Result = F.convertToDouble();
     594           8 :   return false;
     595             : }
     596             : 
     597             : // Implementation of StringRef hashing.
     598     3520644 : hash_code llvm::hash_value(StringRef S) {
     599     3520644 :   return hash_combine_range(S.begin(), S.end());
     600             : }

Generated by: LCOV version 1.13