LCOV - code coverage report
Current view: top level - lib/AsmParser - LLLexer.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 375 410 91.5 %
Date: 2018-02-23 15:42:53 Functions: 24 25 96.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- LLLexer.cpp - Lexer for .ll Files ----------------------------------===//
       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             : // Implement the Lexer for .ll files.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "LLLexer.h"
      15             : #include "llvm/ADT/APInt.h"
      16             : #include "llvm/ADT/STLExtras.h"
      17             : #include "llvm/ADT/StringExtras.h"
      18             : #include "llvm/ADT/Twine.h"
      19             : #include "llvm/IR/DerivedTypes.h"
      20             : #include "llvm/IR/Instruction.h"
      21             : #include "llvm/Support/ErrorHandling.h"
      22             : #include "llvm/Support/SourceMgr.h"
      23             : #include <cassert>
      24             : #include <cctype>
      25             : #include <cstdio>
      26             : 
      27             : using namespace llvm;
      28             : 
      29         204 : bool LLLexer::Error(LocTy ErrorLoc, const Twine &Msg) const {
      30         408 :   ErrorInfo = SM.GetMessage(ErrorLoc, SourceMgr::DK_Error, Msg);
      31         204 :   return true;
      32             : }
      33             : 
      34           0 : void LLLexer::Warning(LocTy WarningLoc, const Twine &Msg) const {
      35           0 :   SM.PrintMessage(WarningLoc, SourceMgr::DK_Warning, Msg);
      36           0 : }
      37             : 
      38             : //===----------------------------------------------------------------------===//
      39             : // Helper functions.
      40             : //===----------------------------------------------------------------------===//
      41             : 
      42             : // atoull - Convert an ascii string of decimal digits into the unsigned long
      43             : // long representation... this does not have to do input error checking,
      44             : // because we know that the input will be matched by a suitable regex...
      45             : //
      46     3567845 : uint64_t LLLexer::atoull(const char *Buffer, const char *End) {
      47             :   uint64_t Result = 0;
      48    15680515 :   for (; Buffer != End; Buffer++) {
      49             :     uint64_t OldRes = Result;
      50     6056335 :     Result *= 10;
      51     6056335 :     Result += *Buffer-'0';
      52     6056335 :     if (Result < OldRes) {  // Uh, oh, overflow detected!!!
      53           0 :       Error("constant bigger than 64 bits detected!");
      54           0 :       return 0;
      55             :     }
      56             :   }
      57             :   return Result;
      58             : }
      59             : 
      60        6793 : uint64_t LLLexer::HexIntToVal(const char *Buffer, const char *End) {
      61             :   uint64_t Result = 0;
      62      196181 :   for (; Buffer != End; ++Buffer) {
      63             :     uint64_t OldRes = Result;
      64       94695 :     Result *= 16;
      65      189390 :     Result += hexDigitValue(*Buffer);
      66             : 
      67       94695 :     if (Result < OldRes) {   // Uh, oh, overflow detected!!!
      68           1 :       Error("constant bigger than 64 bits detected!");
      69           1 :       return 0;
      70             :     }
      71             :   }
      72             :   return Result;
      73             : }
      74             : 
      75         213 : void LLLexer::HexToIntPair(const char *Buffer, const char *End,
      76             :                            uint64_t Pair[2]) {
      77         213 :   Pair[0] = 0;
      78         213 :   if (End - Buffer >= 16) {
      79        6996 :     for (int i = 0; i < 16; i++, Buffer++) {
      80             :       assert(Buffer != End);
      81        3392 :       Pair[0] *= 16;
      82        6784 :       Pair[0] += hexDigitValue(*Buffer);
      83             :     }
      84             :   }
      85         213 :   Pair[1] = 0;
      86        7001 :   for (int i = 0; i < 16 && Buffer != End; i++, Buffer++) {
      87        3394 :     Pair[1] *= 16;
      88        6788 :     Pair[1] += hexDigitValue(*Buffer);
      89             :   }
      90         213 :   if (Buffer != End)
      91           0 :     Error("constant bigger than 128 bits detected!");
      92         213 : }
      93             : 
      94             : /// FP80HexToIntPair - translate an 80 bit FP80 number (20 hexits) into
      95             : /// { low64, high16 } as usual for an APInt.
      96         143 : void LLLexer::FP80HexToIntPair(const char *Buffer, const char *End,
      97             :                            uint64_t Pair[2]) {
      98         143 :   Pair[1] = 0;
      99        1281 :   for (int i=0; i<4 && Buffer != End; i++, Buffer++) {
     100             :     assert(Buffer != End);
     101         569 :     Pair[1] *= 16;
     102        1138 :     Pair[1] += hexDigitValue(*Buffer);
     103             :   }
     104         143 :   Pair[0] = 0;
     105        4687 :   for (int i = 0; i < 16 && Buffer != End; i++, Buffer++) {
     106        2272 :     Pair[0] *= 16;
     107        4544 :     Pair[0] += hexDigitValue(*Buffer);
     108             :   }
     109         143 :   if (Buffer != End)
     110           0 :     Error("constant bigger than 128 bits detected!");
     111         143 : }
     112             : 
     113             : // UnEscapeLexed - Run through the specified buffer and change \xx codes to the
     114             : // appropriate character.
     115      186863 : static void UnEscapeLexed(std::string &Str) {
     116      186863 :   if (Str.empty()) return;
     117             : 
     118      181107 :   char *Buffer = &Str[0], *EndBuffer = Buffer+Str.size();
     119             :   char *BOut = Buffer;
     120     4089220 :   for (char *BIn = Buffer; BIn != EndBuffer; ) {
     121     3908113 :     if (BIn[0] == '\\') {
     122       34208 :       if (BIn < EndBuffer-1 && BIn[1] == '\\') {
     123           7 :         *BOut++ = '\\'; // Two \ becomes one
     124           7 :         BIn += 2;
     125       68402 :       } else if (BIn < EndBuffer-2 &&
     126       68397 :                  isxdigit(static_cast<unsigned char>(BIn[1])) &&
     127       34196 :                  isxdigit(static_cast<unsigned char>(BIn[2]))) {
     128      102588 :         *BOut = hexDigitValue(BIn[1]) * 16 + hexDigitValue(BIn[2]);
     129       34196 :         BIn += 3;                           // Skip over handled chars
     130       34196 :         ++BOut;
     131             :       } else {
     132           5 :         *BOut++ = *BIn++;
     133             :       }
     134             :     } else {
     135     3873905 :       *BOut++ = *BIn++;
     136             :     }
     137             :   }
     138      181107 :   Str.resize(BOut-Buffer);
     139             : }
     140             : 
     141             : /// isLabelChar - Return true for [-a-zA-Z$._0-9].
     142    36395909 : static bool isLabelChar(char C) {
     143    47848940 :   return isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
     144    47847415 :          C == '.' || C == '_';
     145             : }
     146             : 
     147             : /// isLabelTail - Return true if this pointer points to a valid end of a label.
     148             : static const char *isLabelTail(const char *CurPtr) {
     149             :   while (true) {
     150      366711 :     if (CurPtr[0] == ':') return CurPtr+1;
     151      365989 :     if (!isLabelChar(CurPtr[0])) return nullptr;
     152      312596 :     ++CurPtr;
     153             :   }
     154             : }
     155             : 
     156             : //===----------------------------------------------------------------------===//
     157             : // Lexer definition.
     158             : //===----------------------------------------------------------------------===//
     159             : 
     160       31119 : LLLexer::LLLexer(StringRef StartBuf, SourceMgr &sm, SMDiagnostic &Err,
     161       31119 :                  LLVMContext &C)
     162       62238 :   : CurBuf(StartBuf), ErrorInfo(Err), SM(sm), Context(C), APFloatVal(0.0) {
     163       31119 :   CurPtr = CurBuf.begin();
     164       31119 : }
     165             : 
     166   235010307 : int LLLexer::getNextChar() {
     167   235010307 :   char CurChar = *CurPtr++;
     168   235010307 :   switch (CurChar) {
     169   234979308 :   default: return (unsigned char)CurChar;
     170       30999 :   case 0:
     171             :     // A nul character in the stream is either the end of the current buffer or
     172             :     // a random nul in the file.  Disambiguate that here.
     173       30999 :     if (CurPtr-1 != CurBuf.end())
     174             :       return 0;  // Just whitespace.
     175             : 
     176             :     // Otherwise, return end of file.
     177       30997 :     --CurPtr;  // Another call to lex will return EOF again.
     178       30997 :     return EOF;
     179             :   }
     180             : }
     181             : 
     182    23592456 : lltok::Kind LLLexer::LexToken() {
     183             :   while (true) {
     184    53364040 :     TokStart = CurPtr;
     185             : 
     186    53364040 :     int CurChar = getNextChar();
     187    53364040 :     switch (CurChar) {
     188     8390477 :     default:
     189             :       // Handle letters: [a-zA-Z_]
     190     8390477 :       if (isalpha(static_cast<unsigned char>(CurChar)) || CurChar == '_')
     191     8390477 :         return LexIdentifier();
     192             : 
     193             :       return lltok::Error;
     194             :     case EOF: return lltok::Eof;
     195    25382687 :     case 0:
     196             :     case ' ':
     197             :     case '\t':
     198             :     case '\n':
     199             :     case '\r':
     200             :       // Ignore whitespace.
     201    25382687 :       continue;
     202           5 :     case '+': return LexPositive();
     203      479360 :     case '@': return LexAt();
     204         886 :     case '$': return LexDollar();
     205     2792934 :     case '%': return LexPercent();
     206      108695 :     case '"': return LexQuote();
     207       10943 :     case '.':
     208       21886 :       if (const char *Ptr = isLabelTail(CurPtr)) {
     209         698 :         CurPtr = Ptr;
     210         698 :         StrVal.assign(TokStart, CurPtr-1);
     211         698 :         return lltok::LabelStr;
     212       10245 :       }
     213       10245 :       if (CurPtr[0] == '.' && CurPtr[1] == '.') {
     214       10245 :         CurPtr += 2;
     215       10245 :         return lltok::dotdotdot;
     216             :       }
     217             :       return lltok::Error;
     218     4388897 :     case ';':
     219     4388897 :       SkipLineComment();
     220     4388897 :       continue;
     221      254285 :     case '!': return LexExclaim();
     222       57480 :     case '#': return LexHash();
     223     2809684 :     case '0': case '1': case '2': case '3': case '4':
     224             :     case '5': case '6': case '7': case '8': case '9':
     225             :     case '-':
     226     2809684 :       return LexDigitOrNegative();
     227      951232 :     case '=': return lltok::equal;
     228      171276 :     case '[': return lltok::lsquare;
     229      171276 :     case ']': return lltok::rsquare;
     230      275178 :     case '{': return lltok::lbrace;
     231      275117 :     case '}': return lltok::rbrace;
     232     1127044 :     case '<': return lltok::less;
     233     1127044 :     case '>': return lltok::greater;
     234      579759 :     case '(': return lltok::lparen;
     235      579727 :     case ')': return lltok::rparen;
     236     2698508 :     case ',': return lltok::comma;
     237      700076 :     case '*': return lltok::star;
     238    29772067 :     case '|': return lltok::bar;
     239             :     }
     240             :   }
     241             : }
     242             : 
     243     4388897 : void LLLexer::SkipLineComment() {
     244             :   while (true) {
     245   182568713 :     if (CurPtr[0] == '\n' || CurPtr[0] == '\r' || getNextChar() == EOF)
     246     4388897 :       return;
     247             :   }
     248             : }
     249             : 
     250             : /// Lex all tokens that start with an @ character.
     251             : ///   GlobalVar   @\"[^\"]*\"
     252             : ///   GlobalVar   @[-a-zA-Z$._][-a-zA-Z$._0-9]*
     253             : ///   GlobalVarID @[0-9]+
     254      479360 : lltok::Kind LLLexer::LexAt() {
     255      479360 :   return LexVar(lltok::GlobalVar, lltok::GlobalID);
     256             : }
     257             : 
     258         886 : lltok::Kind LLLexer::LexDollar() {
     259        1772 :   if (const char *Ptr = isLabelTail(TokStart)) {
     260           0 :     CurPtr = Ptr;
     261           0 :     StrVal.assign(TokStart, CurPtr - 1);
     262           0 :     return lltok::LabelStr;
     263             :   }
     264             : 
     265             :   // Handle DollarStringConstant: $\"[^\"]*\"
     266         886 :   if (CurPtr[0] == '"') {
     267         170 :     ++CurPtr;
     268             : 
     269             :     while (true) {
     270        3151 :       int CurChar = getNextChar();
     271             : 
     272        3151 :       if (CurChar == EOF) {
     273           0 :         Error("end of file in COMDAT variable name");
     274           0 :         return lltok::Error;
     275             :       }
     276        3151 :       if (CurChar == '"') {
     277         170 :         StrVal.assign(TokStart + 2, CurPtr - 1);
     278         170 :         UnEscapeLexed(StrVal);
     279         170 :         if (StringRef(StrVal).find_first_of(0) != StringRef::npos) {
     280           0 :           Error("Null bytes are not allowed in names");
     281           0 :           return lltok::Error;
     282             :         }
     283             :         return lltok::ComdatVar;
     284             :       }
     285             :     }
     286             :   }
     287             : 
     288             :   // Handle ComdatVarName: $[-a-zA-Z$._][-a-zA-Z$._0-9]*
     289         716 :   if (ReadVarName())
     290             :     return lltok::ComdatVar;
     291             : 
     292           0 :   return lltok::Error;
     293             : }
     294             : 
     295             : /// ReadString - Read a string until the closing quote.
     296      108695 : lltok::Kind LLLexer::ReadString(lltok::Kind kind) {
     297      108695 :   const char *Start = CurPtr;
     298             :   while (true) {
     299     3111617 :     int CurChar = getNextChar();
     300             : 
     301     3111617 :     if (CurChar == EOF) {
     302           0 :       Error("end of file in string constant");
     303           0 :       return lltok::Error;
     304             :     }
     305     3111617 :     if (CurChar == '"') {
     306      108695 :       StrVal.assign(Start, CurPtr-1);
     307      108695 :       UnEscapeLexed(StrVal);
     308      108695 :       return kind;
     309             :     }
     310             :   }
     311             : }
     312             : 
     313             : /// ReadVarName - Read the rest of a token containing a variable name.
     314     3262201 : bool LLLexer::ReadVarName() {
     315     3262201 :   const char *NameStart = CurPtr;
     316     3262201 :   if (isalpha(static_cast<unsigned char>(CurPtr[0])) ||
     317      546589 :       CurPtr[0] == '-' || CurPtr[0] == '$' ||
     318      535406 :       CurPtr[0] == '.' || CurPtr[0] == '_') {
     319     2810238 :     ++CurPtr;
     320    36448116 :     while (isalnum(static_cast<unsigned char>(CurPtr[0])) ||
     321     4419108 :            CurPtr[0] == '-' || CurPtr[0] == '$' ||
     322    20904126 :            CurPtr[0] == '.' || CurPtr[0] == '_')
     323    14608436 :       ++CurPtr;
     324             : 
     325     2810238 :     StrVal.assign(NameStart, CurPtr);
     326     2810238 :     return true;
     327             :   }
     328             :   return false;
     329             : }
     330             : 
     331     3272294 : lltok::Kind LLLexer::LexVar(lltok::Kind Var, lltok::Kind VarID) {
     332             :   // Handle StringConstant: \"[^\"]*\"
     333     3272294 :   if (CurPtr[0] == '"') {
     334       10809 :     ++CurPtr;
     335             : 
     336             :     while (true) {
     337      351673 :       int CurChar = getNextChar();
     338             : 
     339      351673 :       if (CurChar == EOF) {
     340           0 :         Error("end of file in global variable name");
     341           0 :         return lltok::Error;
     342             :       }
     343      351673 :       if (CurChar == '"') {
     344       10809 :         StrVal.assign(TokStart+2, CurPtr-1);
     345       10809 :         UnEscapeLexed(StrVal);
     346       10809 :         if (StringRef(StrVal).find_first_of(0) != StringRef::npos) {
     347           1 :           Error("Null bytes are not allowed in names");
     348           1 :           return lltok::Error;
     349             :         }
     350             :         return Var;
     351             :       }
     352             :     }
     353             :   }
     354             : 
     355             :   // Handle VarName: [-a-zA-Z$._][-a-zA-Z$._0-9]*
     356     3261485 :   if (ReadVarName())
     357             :     return Var;
     358             : 
     359             :   // Handle VarID: [0-9]+
     360      451963 :   if (isdigit(static_cast<unsigned char>(CurPtr[0]))) {
     361      532150 :     for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
     362             :       /*empty*/;
     363             : 
     364      451963 :     uint64_t Val = atoull(TokStart+1, CurPtr);
     365      451963 :     if ((unsigned)Val != Val)
     366           0 :       Error("invalid value number (too large)!");
     367      451963 :     UIntVal = unsigned(Val);
     368      451963 :     return VarID;
     369             :   }
     370             :   return lltok::Error;
     371             : }
     372             : 
     373             : /// Lex all tokens that start with a % character.
     374             : ///   LocalVar   ::= %\"[^\"]*\"
     375             : ///   LocalVar   ::= %[-a-zA-Z$._][-a-zA-Z$._0-9]*
     376             : ///   LocalVarID ::= %[0-9]+
     377     2792934 : lltok::Kind LLLexer::LexPercent() {
     378     2792934 :   return LexVar(lltok::LocalVar, lltok::LocalVarID);
     379             : }
     380             : 
     381             : /// Lex all tokens that start with a " character.
     382             : ///   QuoteLabel        "[^"]+":
     383             : ///   StringConstant    "[^"]*"
     384      108695 : lltok::Kind LLLexer::LexQuote() {
     385      108695 :   lltok::Kind kind = ReadString(lltok::StringConstant);
     386      108695 :   if (kind == lltok::Error || kind == lltok::Eof)
     387             :     return kind;
     388             : 
     389      108695 :   if (CurPtr[0] == ':') {
     390         541 :     ++CurPtr;
     391         541 :     if (StringRef(StrVal).find_first_of(0) != StringRef::npos) {
     392           1 :       Error("Null bytes are not allowed in names");
     393             :       kind = lltok::Error;
     394             :     } else {
     395             :       kind = lltok::LabelStr;
     396             :     }
     397             :   }
     398             : 
     399             :   return kind;
     400             : }
     401             : 
     402             : /// Lex all tokens that start with a ! character.
     403             : ///    !foo
     404             : ///    !
     405      254285 : lltok::Kind LLLexer::LexExclaim() {
     406             :   // Lex a metadata name as a MetadataVar.
     407      254285 :   if (isalpha(static_cast<unsigned char>(CurPtr[0])) ||
     408      187130 :       CurPtr[0] == '-' || CurPtr[0] == '$' ||
     409      187130 :       CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\') {
     410       67189 :     ++CurPtr;
     411     1272317 :     while (isalnum(static_cast<unsigned char>(CurPtr[0])) ||
     412       80016 :            CurPtr[0] == '-' || CurPtr[0] == '$' ||
     413      700711 :            CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\')
     414      562556 :       ++CurPtr;
     415             : 
     416       67189 :     StrVal.assign(TokStart+1, CurPtr);   // Skip !
     417       67189 :     UnEscapeLexed(StrVal);
     418       67189 :     return lltok::MetadataVar;
     419             :   }
     420             :   return lltok::exclaim;
     421             : }
     422             : 
     423             : /// Lex all tokens that start with a # character.
     424             : ///    AttrGrpID ::= #[0-9]+
     425       57480 : lltok::Kind LLLexer::LexHash() {
     426             :   // Handle AttrGrpID: #[0-9]+
     427       57480 :   if (isdigit(static_cast<unsigned char>(CurPtr[0]))) {
     428       57913 :     for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
     429             :       /*empty*/;
     430             : 
     431       57480 :     uint64_t Val = atoull(TokStart+1, CurPtr);
     432       57480 :     if ((unsigned)Val != Val)
     433           0 :       Error("invalid value number (too large)!");
     434       57480 :     UIntVal = unsigned(Val);
     435       57480 :     return lltok::AttrGrpID;
     436             :   }
     437             : 
     438             :   return lltok::Error;
     439             : }
     440             : 
     441             : /// Lex a label, integer type, keyword, or hexadecimal integer constant.
     442             : ///    Label           [-a-zA-Z$._0-9]+:
     443             : ///    IntegerType     i[0-9]+
     444             : ///    Keyword         sdiv, float, ...
     445             : ///    HexIntConstant  [us]0x[0-9A-Fa-f]+
     446     8390477 : lltok::Kind LLLexer::LexIdentifier() {
     447     8390477 :   const char *StartChar = CurPtr;
     448     8390477 :   const char *IntEnd = CurPtr[-1] == 'i' ? nullptr : StartChar;
     449             :   const char *KeywordEnd = nullptr;
     450             : 
     451    58049995 :   for (; isLabelChar(*CurPtr); ++CurPtr) {
     452             :     // If we decide this is an integer, remember the end of the sequence.
     453    24829759 :     if (!IntEnd && !isdigit(static_cast<unsigned char>(*CurPtr)))
     454             :       IntEnd = CurPtr;
     455    24829759 :     if (!KeywordEnd && !isalnum(static_cast<unsigned char>(*CurPtr)) &&
     456             :         *CurPtr != '_')
     457             :       KeywordEnd = CurPtr;
     458             :   }
     459             : 
     460             :   // If we stopped due to a colon, this really is a label.
     461     8390477 :   if (*CurPtr == ':') {
     462      285130 :     StrVal.assign(StartChar-1, CurPtr++);
     463      285130 :     return lltok::LabelStr;
     464             :   }
     465             : 
     466             :   // Otherwise, this wasn't a label.  If this was valid as an integer type,
     467             :   // return it.
     468     8105347 :   if (!IntEnd) IntEnd = CurPtr;
     469     8105347 :   if (IntEnd != StartChar) {
     470     3058402 :     CurPtr = IntEnd;
     471     3058402 :     uint64_t NumBits = atoull(StartChar, CurPtr);
     472     3058402 :     if (NumBits < IntegerType::MIN_INT_BITS ||
     473             :         NumBits > IntegerType::MAX_INT_BITS) {
     474           1 :       Error("bitwidth for integer type out of range!");
     475           1 :       return lltok::Error;
     476             :     }
     477     3058401 :     TyVal = IntegerType::get(Context, NumBits);
     478     3058401 :     return lltok::Type;
     479             :   }
     480             : 
     481             :   // Otherwise, this was a letter sequence.  See which keyword this is.
     482     5046945 :   if (!KeywordEnd) KeywordEnd = CurPtr;
     483     5046945 :   CurPtr = KeywordEnd;
     484     5046945 :   --StartChar;
     485     5046945 :   StringRef Keyword(StartChar, CurPtr - StartChar);
     486             : 
     487             : #define KEYWORD(STR)                                                           \
     488             :   do {                                                                         \
     489             :     if (Keyword == #STR)                                                       \
     490             :       return lltok::kw_##STR;                                                  \
     491             :   } while (false)
     492             : 
     493             :   KEYWORD(true);    KEYWORD(false);
     494             :   KEYWORD(declare); KEYWORD(define);
     495             :   KEYWORD(global);  KEYWORD(constant);
     496             : 
     497             :   KEYWORD(dso_local);
     498             :   KEYWORD(dso_preemptable);
     499             : 
     500             :   KEYWORD(private);
     501             :   KEYWORD(internal);
     502             :   KEYWORD(available_externally);
     503             :   KEYWORD(linkonce);
     504             :   KEYWORD(linkonce_odr);
     505             :   KEYWORD(weak); // Use as a linkage, and a modifier for "cmpxchg".
     506             :   KEYWORD(weak_odr);
     507             :   KEYWORD(appending);
     508             :   KEYWORD(dllimport);
     509             :   KEYWORD(dllexport);
     510             :   KEYWORD(common);
     511             :   KEYWORD(default);
     512             :   KEYWORD(hidden);
     513             :   KEYWORD(protected);
     514             :   KEYWORD(unnamed_addr);
     515             :   KEYWORD(local_unnamed_addr);
     516             :   KEYWORD(externally_initialized);
     517             :   KEYWORD(extern_weak);
     518             :   KEYWORD(external);
     519             :   KEYWORD(thread_local);
     520             :   KEYWORD(localdynamic);
     521             :   KEYWORD(initialexec);
     522             :   KEYWORD(localexec);
     523             :   KEYWORD(zeroinitializer);
     524             :   KEYWORD(undef);
     525             :   KEYWORD(null);
     526             :   KEYWORD(none);
     527             :   KEYWORD(to);
     528             :   KEYWORD(caller);
     529             :   KEYWORD(within);
     530             :   KEYWORD(from);
     531             :   KEYWORD(tail);
     532             :   KEYWORD(musttail);
     533             :   KEYWORD(notail);
     534             :   KEYWORD(target);
     535             :   KEYWORD(triple);
     536             :   KEYWORD(source_filename);
     537             :   KEYWORD(unwind);
     538             :   KEYWORD(deplibs);             // FIXME: Remove in 4.0.
     539             :   KEYWORD(datalayout);
     540             :   KEYWORD(volatile);
     541             :   KEYWORD(atomic);
     542             :   KEYWORD(unordered);
     543             :   KEYWORD(monotonic);
     544             :   KEYWORD(acquire);
     545             :   KEYWORD(release);
     546             :   KEYWORD(acq_rel);
     547             :   KEYWORD(seq_cst);
     548             :   KEYWORD(syncscope);
     549             : 
     550             :   KEYWORD(nnan);
     551             :   KEYWORD(ninf);
     552             :   KEYWORD(nsz);
     553             :   KEYWORD(arcp);
     554             :   KEYWORD(contract);
     555             :   KEYWORD(reassoc);
     556             :   KEYWORD(afn);
     557             :   KEYWORD(fast);
     558             :   KEYWORD(nuw);
     559             :   KEYWORD(nsw);
     560             :   KEYWORD(exact);
     561             :   KEYWORD(inbounds);
     562             :   KEYWORD(inrange);
     563             :   KEYWORD(align);
     564             :   KEYWORD(addrspace);
     565             :   KEYWORD(section);
     566             :   KEYWORD(alias);
     567             :   KEYWORD(ifunc);
     568             :   KEYWORD(module);
     569             :   KEYWORD(asm);
     570             :   KEYWORD(sideeffect);
     571             :   KEYWORD(alignstack);
     572             :   KEYWORD(inteldialect);
     573             :   KEYWORD(gc);
     574             :   KEYWORD(prefix);
     575             :   KEYWORD(prologue);
     576             : 
     577             :   KEYWORD(ccc);
     578             :   KEYWORD(fastcc);
     579             :   KEYWORD(coldcc);
     580             :   KEYWORD(x86_stdcallcc);
     581             :   KEYWORD(x86_fastcallcc);
     582             :   KEYWORD(x86_thiscallcc);
     583             :   KEYWORD(x86_vectorcallcc);
     584             :   KEYWORD(arm_apcscc);
     585             :   KEYWORD(arm_aapcscc);
     586             :   KEYWORD(arm_aapcs_vfpcc);
     587             :   KEYWORD(msp430_intrcc);
     588             :   KEYWORD(avr_intrcc);
     589             :   KEYWORD(avr_signalcc);
     590             :   KEYWORD(ptx_kernel);
     591             :   KEYWORD(ptx_device);
     592             :   KEYWORD(spir_kernel);
     593             :   KEYWORD(spir_func);
     594             :   KEYWORD(intel_ocl_bicc);
     595             :   KEYWORD(x86_64_sysvcc);
     596             :   KEYWORD(win64cc);
     597             :   KEYWORD(x86_regcallcc);
     598             :   KEYWORD(webkit_jscc);
     599             :   KEYWORD(swiftcc);
     600             :   KEYWORD(anyregcc);
     601             :   KEYWORD(preserve_mostcc);
     602             :   KEYWORD(preserve_allcc);
     603             :   KEYWORD(ghccc);
     604             :   KEYWORD(x86_intrcc);
     605             :   KEYWORD(hhvmcc);
     606             :   KEYWORD(hhvm_ccc);
     607             :   KEYWORD(cxx_fast_tlscc);
     608             :   KEYWORD(amdgpu_vs);
     609             :   KEYWORD(amdgpu_ls);
     610             :   KEYWORD(amdgpu_hs);
     611             :   KEYWORD(amdgpu_es);
     612             :   KEYWORD(amdgpu_gs);
     613             :   KEYWORD(amdgpu_ps);
     614             :   KEYWORD(amdgpu_cs);
     615             :   KEYWORD(amdgpu_kernel);
     616             : 
     617             :   KEYWORD(cc);
     618             :   KEYWORD(c);
     619             : 
     620             :   KEYWORD(attributes);
     621             : 
     622             :   KEYWORD(alwaysinline);
     623             :   KEYWORD(allocsize);
     624             :   KEYWORD(argmemonly);
     625             :   KEYWORD(builtin);
     626             :   KEYWORD(byval);
     627             :   KEYWORD(inalloca);
     628             :   KEYWORD(cold);
     629             :   KEYWORD(convergent);
     630             :   KEYWORD(dereferenceable);
     631             :   KEYWORD(dereferenceable_or_null);
     632             :   KEYWORD(inaccessiblememonly);
     633             :   KEYWORD(inaccessiblemem_or_argmemonly);
     634             :   KEYWORD(inlinehint);
     635             :   KEYWORD(inreg);
     636             :   KEYWORD(jumptable);
     637             :   KEYWORD(minsize);
     638             :   KEYWORD(naked);
     639             :   KEYWORD(nest);
     640             :   KEYWORD(noalias);
     641             :   KEYWORD(nobuiltin);
     642             :   KEYWORD(nocapture);
     643             :   KEYWORD(noduplicate);
     644             :   KEYWORD(noimplicitfloat);
     645             :   KEYWORD(noinline);
     646             :   KEYWORD(norecurse);
     647             :   KEYWORD(nonlazybind);
     648             :   KEYWORD(nonnull);
     649             :   KEYWORD(noredzone);
     650             :   KEYWORD(noreturn);
     651             :   KEYWORD(nounwind);
     652             :   KEYWORD(optnone);
     653             :   KEYWORD(optsize);
     654             :   KEYWORD(readnone);
     655             :   KEYWORD(readonly);
     656             :   KEYWORD(returned);
     657             :   KEYWORD(returns_twice);
     658             :   KEYWORD(signext);
     659             :   KEYWORD(speculatable);
     660             :   KEYWORD(sret);
     661             :   KEYWORD(ssp);
     662             :   KEYWORD(sspreq);
     663             :   KEYWORD(sspstrong);
     664             :   KEYWORD(strictfp);
     665             :   KEYWORD(safestack);
     666             :   KEYWORD(sanitize_address);
     667             :   KEYWORD(sanitize_hwaddress);
     668             :   KEYWORD(sanitize_thread);
     669             :   KEYWORD(sanitize_memory);
     670             :   KEYWORD(swifterror);
     671             :   KEYWORD(swiftself);
     672             :   KEYWORD(uwtable);
     673             :   KEYWORD(writeonly);
     674             :   KEYWORD(zeroext);
     675             : 
     676             :   KEYWORD(type);
     677             :   KEYWORD(opaque);
     678             : 
     679             :   KEYWORD(comdat);
     680             : 
     681             :   // Comdat types
     682             :   KEYWORD(any);
     683             :   KEYWORD(exactmatch);
     684             :   KEYWORD(largest);
     685             :   KEYWORD(noduplicates);
     686             :   KEYWORD(samesize);
     687             : 
     688             :   KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle);
     689             :   KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge);
     690             :   KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole);
     691             :   KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une);
     692             : 
     693             :   KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax);
     694             :   KEYWORD(umin);
     695             : 
     696             :   KEYWORD(x);
     697             :   KEYWORD(blockaddress);
     698             : 
     699             :   // Metadata types.
     700             :   KEYWORD(distinct);
     701             : 
     702             :   // Use-list order directives.
     703             :   KEYWORD(uselistorder);
     704             :   KEYWORD(uselistorder_bb);
     705             : 
     706             :   KEYWORD(personality);
     707             :   KEYWORD(cleanup);
     708             :   KEYWORD(catch);
     709             :   KEYWORD(filter);
     710             : 
     711             : #undef KEYWORD
     712             : 
     713             :   // Keywords for types.
     714             : #define TYPEKEYWORD(STR, LLVMTY)                                               \
     715             :   do {                                                                         \
     716             :     if (Keyword == STR) {                                                      \
     717             :       TyVal = LLVMTY;                                                          \
     718             :       return lltok::Type;                                                      \
     719             :     }                                                                          \
     720             :   } while (false)
     721             : 
     722      201861 :   TYPEKEYWORD("void",      Type::getVoidTy(Context));
     723       41637 :   TYPEKEYWORD("half",      Type::getHalfTy(Context));
     724      419771 :   TYPEKEYWORD("float",     Type::getFloatTy(Context));
     725      198713 :   TYPEKEYWORD("double",    Type::getDoubleTy(Context));
     726        2638 :   TYPEKEYWORD("x86_fp80",  Type::getX86_FP80Ty(Context));
     727        6486 :   TYPEKEYWORD("fp128",     Type::getFP128Ty(Context));
     728         840 :   TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
     729      119194 :   TYPEKEYWORD("label",     Type::getLabelTy(Context));
     730       10043 :   TYPEKEYWORD("metadata",  Type::getMetadataTy(Context));
     731       21293 :   TYPEKEYWORD("x86_mmx",   Type::getX86_MMXTy(Context));
     732        1066 :   TYPEKEYWORD("token",     Type::getTokenTy(Context));
     733             : 
     734             : #undef TYPEKEYWORD
     735             : 
     736             :   // Keywords for instructions.
     737             : #define INSTKEYWORD(STR, Enum)                                                 \
     738             :   do {                                                                         \
     739             :     if (Keyword == #STR) {                                                     \
     740             :       UIntVal = Instruction::Enum;                                             \
     741             :       return lltok::kw_##STR;                                                  \
     742             :     }                                                                          \
     743             :   } while (false)
     744             : 
     745       58402 :   INSTKEYWORD(add,   Add);  INSTKEYWORD(fadd,   FAdd);
     746       15026 :   INSTKEYWORD(sub,   Sub);  INSTKEYWORD(fsub,   FSub);
     747       19418 :   INSTKEYWORD(mul,   Mul);  INSTKEYWORD(fmul,   FMul);
     748        6187 :   INSTKEYWORD(udiv,  UDiv); INSTKEYWORD(sdiv,  SDiv); INSTKEYWORD(fdiv,  FDiv);
     749        2571 :   INSTKEYWORD(urem,  URem); INSTKEYWORD(srem,  SRem); INSTKEYWORD(frem,  FRem);
     750       21610 :   INSTKEYWORD(shl,   Shl);  INSTKEYWORD(lshr,  LShr); INSTKEYWORD(ashr,  AShr);
     751       31022 :   INSTKEYWORD(and,   And);  INSTKEYWORD(or,    Or);   INSTKEYWORD(xor,   Xor);
     752       60299 :   INSTKEYWORD(icmp,  ICmp); INSTKEYWORD(fcmp,  FCmp);
     753             : 
     754       22030 :   INSTKEYWORD(phi,         PHI);
     755      120908 :   INSTKEYWORD(call,        Call);
     756       10060 :   INSTKEYWORD(trunc,       Trunc);
     757       15515 :   INSTKEYWORD(zext,        ZExt);
     758       14766 :   INSTKEYWORD(sext,        SExt);
     759        1310 :   INSTKEYWORD(fptrunc,     FPTrunc);
     760        2372 :   INSTKEYWORD(fpext,       FPExt);
     761        2942 :   INSTKEYWORD(uitofp,      UIToFP);
     762        3993 :   INSTKEYWORD(sitofp,      SIToFP);
     763        2028 :   INSTKEYWORD(fptoui,      FPToUI);
     764        2599 :   INSTKEYWORD(fptosi,      FPToSI);
     765        2052 :   INSTKEYWORD(inttoptr,    IntToPtr);
     766        2217 :   INSTKEYWORD(ptrtoint,    PtrToInt);
     767       56572 :   INSTKEYWORD(bitcast,     BitCast);
     768         708 :   INSTKEYWORD(addrspacecast, AddrSpaceCast);
     769       22386 :   INSTKEYWORD(select,      Select);
     770         210 :   INSTKEYWORD(va_arg,      VAArg);
     771      214946 :   INSTKEYWORD(ret,         Ret);
     772       72651 :   INSTKEYWORD(br,          Br);
     773        1356 :   INSTKEYWORD(switch,      Switch);
     774         315 :   INSTKEYWORD(indirectbr,  IndirectBr);
     775        1808 :   INSTKEYWORD(invoke,      Invoke);
     776         239 :   INSTKEYWORD(resume,      Resume);
     777        3514 :   INSTKEYWORD(unreachable, Unreachable);
     778             : 
     779       46070 :   INSTKEYWORD(alloca,      Alloca);
     780      148466 :   INSTKEYWORD(load,        Load);
     781      116904 :   INSTKEYWORD(store,       Store);
     782        1060 :   INSTKEYWORD(cmpxchg,     AtomicCmpXchg);
     783        5801 :   INSTKEYWORD(atomicrmw,   AtomicRMW);
     784         663 :   INSTKEYWORD(fence,       Fence);
     785      120714 :   INSTKEYWORD(getelementptr, GetElementPtr);
     786             : 
     787       20143 :   INSTKEYWORD(extractelement, ExtractElement);
     788       29586 :   INSTKEYWORD(insertelement,  InsertElement);
     789       36685 :   INSTKEYWORD(shufflevector,  ShuffleVector);
     790        4504 :   INSTKEYWORD(extractvalue,   ExtractValue);
     791        1367 :   INSTKEYWORD(insertvalue,    InsertValue);
     792        1053 :   INSTKEYWORD(landingpad,     LandingPad);
     793         164 :   INSTKEYWORD(cleanupret,     CleanupRet);
     794         185 :   INSTKEYWORD(catchret,       CatchRet);
     795         245 :   INSTKEYWORD(catchswitch,  CatchSwitch);
     796         267 :   INSTKEYWORD(catchpad,     CatchPad);
     797         249 :   INSTKEYWORD(cleanuppad,   CleanupPad);
     798             : 
     799             : #undef INSTKEYWORD
     800             : 
     801             : #define DWKEYWORD(TYPE, TOKEN)                                                 \
     802             :   do {                                                                         \
     803             :     if (Keyword.startswith("DW_" #TYPE "_")) {                                 \
     804             :       StrVal.assign(Keyword.begin(), Keyword.end());                           \
     805             :       return lltok::TOKEN;                                                     \
     806             :     }                                                                          \
     807             :   } while (false)
     808             : 
     809        7154 :   DWKEYWORD(TAG, DwarfTag);
     810        2604 :   DWKEYWORD(ATE, DwarfAttEncoding);
     811         114 :   DWKEYWORD(VIRTUALITY, DwarfVirtuality);
     812        3148 :   DWKEYWORD(LANG, DwarfLang);
     813         120 :   DWKEYWORD(CC, DwarfCC);
     814         720 :   DWKEYWORD(OP, DwarfOp);
     815          46 :   DWKEYWORD(MACINFO, DwarfMacinfo);
     816             : 
     817             : #undef DWKEYWORD
     818             : 
     819             :   if (Keyword.startswith("DIFlag")) {
     820        3165 :     StrVal.assign(Keyword.begin(), Keyword.end());
     821        3165 :     return lltok::DIFlag;
     822             :   }
     823             : 
     824             :   if (Keyword.startswith("CSK_")) {
     825         112 :     StrVal.assign(Keyword.begin(), Keyword.end());
     826         112 :     return lltok::ChecksumKind;
     827             :   }
     828             : 
     829             :   if (Keyword == "NoDebug" || Keyword == "FullDebug" ||
     830             :       Keyword == "LineTablesOnly") {
     831        1407 :     StrVal.assign(Keyword.begin(), Keyword.end());
     832        1407 :     return lltok::EmissionKind;
     833             :   }
     834             : 
     835             :   // Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
     836             :   // the CFE to avoid forcing it to deal with 64-bit numbers.
     837         140 :   if ((TokStart[0] == 'u' || TokStart[0] == 's') &&
     838          72 :       TokStart[1] == '0' && TokStart[2] == 'x' &&
     839          24 :       isxdigit(static_cast<unsigned char>(TokStart[3]))) {
     840          24 :     int len = CurPtr-TokStart-3;
     841          24 :     uint32_t bits = len * 4;
     842          24 :     StringRef HexStr(TokStart + 3, len);
     843          24 :     if (!all_of(HexStr, isxdigit)) {
     844             :       // Bad token, return it as an error.
     845           1 :       CurPtr = TokStart+3;
     846           1 :       return lltok::Error;
     847             :     }
     848          23 :     APInt Tmp(bits, HexStr, 16);
     849             :     uint32_t activeBits = Tmp.getActiveBits();
     850          23 :     if (activeBits > 0 && activeBits < bits)
     851          44 :       Tmp = Tmp.trunc(activeBits);
     852          92 :     APSIntVal = APSInt(Tmp, TokStart[0] == 'u');
     853             :     return lltok::APSInt;
     854             :   }
     855             : 
     856             :   // If this is "cc1234", return this as just "cc".
     857          92 :   if (TokStart[0] == 'c' && TokStart[1] == 'c') {
     858          86 :     CurPtr = TokStart+2;
     859          86 :     return lltok::kw_cc;
     860             :   }
     861             : 
     862             :   // Finally, if this isn't known, return an error.
     863           6 :   CurPtr = TokStart+1;
     864           6 :   return lltok::Error;
     865             : }
     866             : 
     867             : /// Lex all tokens that start with a 0x prefix, knowing they match and are not
     868             : /// labels.
     869             : ///    HexFPConstant     0x[0-9A-Fa-f]+
     870             : ///    HexFP80Constant   0xK[0-9A-Fa-f]+
     871             : ///    HexFP128Constant  0xL[0-9A-Fa-f]+
     872             : ///    HexPPC128Constant 0xM[0-9A-Fa-f]+
     873             : ///    HexHalfConstant   0xH[0-9A-Fa-f]+
     874        7149 : lltok::Kind LLLexer::Lex0x() {
     875        7149 :   CurPtr = TokStart + 2;
     876             : 
     877             :   char Kind;
     878        7149 :   if ((CurPtr[0] >= 'K' && CurPtr[0] <= 'M') || CurPtr[0] == 'H') {
     879         857 :     Kind = *CurPtr++;
     880             :   } else {
     881             :     Kind = 'J';
     882             :   }
     883             : 
     884        7149 :   if (!isxdigit(static_cast<unsigned char>(CurPtr[0]))) {
     885             :     // Bad token, return it as an error.
     886           0 :     CurPtr = TokStart+1;
     887           0 :     return lltok::Error;
     888             :   }
     889             : 
     890      215819 :   while (isxdigit(static_cast<unsigned char>(CurPtr[0])))
     891      104335 :     ++CurPtr;
     892             : 
     893        7149 :   if (Kind == 'J') {
     894             :     // HexFPConstant - Floating point constant represented in IEEE format as a
     895             :     // hexadecimal number for when exponential notation is not precise enough.
     896             :     // Half, Float, and double only.
     897       12584 :     APFloatVal = APFloat(APFloat::IEEEdouble(),
     898       12584 :                          APInt(64, HexIntToVal(TokStart + 2, CurPtr)));
     899        6292 :     return lltok::APFloat;
     900             :   }
     901             : 
     902             :   uint64_t Pair[2];
     903         857 :   switch (Kind) {
     904           0 :   default: llvm_unreachable("Unknown kind!");
     905         143 :   case 'K':
     906             :     // F80HexFPConstant - x87 long double in hexadecimal format (10 bytes)
     907         143 :     FP80HexToIntPair(TokStart+3, CurPtr, Pair);
     908         429 :     APFloatVal = APFloat(APFloat::x87DoubleExtended(), APInt(80, Pair));
     909         143 :     return lltok::APFloat;
     910         146 :   case 'L':
     911             :     // F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes)
     912         146 :     HexToIntPair(TokStart+3, CurPtr, Pair);
     913         438 :     APFloatVal = APFloat(APFloat::IEEEquad(), APInt(128, Pair));
     914         146 :     return lltok::APFloat;
     915          67 :   case 'M':
     916             :     // PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes)
     917          67 :     HexToIntPair(TokStart+3, CurPtr, Pair);
     918         201 :     APFloatVal = APFloat(APFloat::PPCDoubleDouble(), APInt(128, Pair));
     919          67 :     return lltok::APFloat;
     920         501 :   case 'H':
     921        1002 :     APFloatVal = APFloat(APFloat::IEEEhalf(),
     922        1002 :                          APInt(16,HexIntToVal(TokStart+3, CurPtr)));
     923         501 :     return lltok::APFloat;
     924             :   }
     925             : }
     926             : 
     927             : /// Lex tokens for a label or a numeric constant, possibly starting with -.
     928             : ///    Label             [-a-zA-Z$._0-9]+:
     929             : ///    NInteger          -[0-9]+
     930             : ///    FPConstant        [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
     931             : ///    PInteger          [0-9]+
     932             : ///    HexFPConstant     0x[0-9A-Fa-f]+
     933             : ///    HexFP80Constant   0xK[0-9A-Fa-f]+
     934             : ///    HexFP128Constant  0xL[0-9A-Fa-f]+
     935             : ///    HexPPC128Constant 0xM[0-9A-Fa-f]+
     936     2809684 : lltok::Kind LLLexer::LexDigitOrNegative() {
     937             :   // If the letter after the negative is not a number, this is probably a label.
     938     2861363 :   if (!isdigit(static_cast<unsigned char>(TokStart[0])) &&
     939       51679 :       !isdigit(static_cast<unsigned char>(CurPtr[0]))) {
     940             :     // Okay, this is not a number after the -, it's probably a label.
     941           0 :     if (const char *End = isLabelTail(CurPtr)) {
     942           0 :       StrVal.assign(TokStart, End-1);
     943           0 :       CurPtr = End;
     944           0 :       return lltok::LabelStr;
     945             :     }
     946             : 
     947             :     return lltok::Error;
     948             :   }
     949             : 
     950             :   // At this point, it is either a label, int or fp constant.
     951             : 
     952             :   // Skip digits, we have at least one.
     953     4043277 :   for (; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
     954             :     /*empty*/;
     955             : 
     956             :   // Check to see if this really is a label afterall, e.g. "-1:".
     957     2809684 :   if (isLabelChar(CurPtr[0]) || CurPtr[0] == ':') {
     958       42286 :     if (const char *End = isLabelTail(CurPtr)) {
     959          24 :       StrVal.assign(TokStart, End-1);
     960          24 :       CurPtr = End;
     961          24 :       return lltok::LabelStr;
     962             :     }
     963             :   }
     964             : 
     965             :   // If the next character is a '.', then it is a fp value, otherwise its
     966             :   // integer.
     967     2809660 :   if (CurPtr[0] != '.') {
     968     2774700 :     if (TokStart[0] == '0' && TokStart[1] == 'x')
     969        7149 :       return Lex0x();
     970     8302653 :     APSIntVal = APSInt(StringRef(TokStart, CurPtr - TokStart));
     971     2767551 :     return lltok::APSInt;
     972             :   }
     973             : 
     974       34960 :   ++CurPtr;
     975             : 
     976             :   // Skip over [0-9]*([eE][-+]?[0-9]+)?
     977      263882 :   while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
     978             : 
     979       34960 :   if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
     980       47873 :     if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
     981       15911 :         ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
     982       15911 :           isdigit(static_cast<unsigned char>(CurPtr[2])))) {
     983       16051 :       CurPtr += 2;
     984       47982 :       while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
     985             :     }
     986             :   }
     987             : 
     988      104880 :   APFloatVal = APFloat(APFloat::IEEEdouble(),
     989       34960 :                        StringRef(TokStart, CurPtr - TokStart));
     990       34960 :   return lltok::APFloat;
     991             : }
     992             : 
     993             : /// Lex a floating point constant starting with +.
     994             : ///    FPConstant  [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
     995           5 : lltok::Kind LLLexer::LexPositive() {
     996             :   // If the letter after the negative is a number, this is probably not a
     997             :   // label.
     998           5 :   if (!isdigit(static_cast<unsigned char>(CurPtr[0])))
     999             :     return lltok::Error;
    1000             : 
    1001             :   // Skip digits.
    1002           5 :   for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
    1003             :     /*empty*/;
    1004             : 
    1005             :   // At this point, we need a '.'.
    1006           5 :   if (CurPtr[0] != '.') {
    1007           0 :     CurPtr = TokStart+1;
    1008           0 :     return lltok::Error;
    1009             :   }
    1010             : 
    1011           5 :   ++CurPtr;
    1012             : 
    1013             :   // Skip over [0-9]*([eE][-+]?[0-9]+)?
    1014          15 :   while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
    1015             : 
    1016           5 :   if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
    1017           0 :     if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
    1018           0 :         ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
    1019           0 :         isdigit(static_cast<unsigned char>(CurPtr[2])))) {
    1020           0 :       CurPtr += 2;
    1021           0 :       while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
    1022             :     }
    1023             :   }
    1024             : 
    1025          15 :   APFloatVal = APFloat(APFloat::IEEEdouble(),
    1026           5 :                        StringRef(TokStart, CurPtr - TokStart));
    1027           5 :   return lltok::APFloat;
    1028             : }

Generated by: LCOV version 1.13