LCOV - code coverage report
Current view: top level - lib/AsmParser - LLLexer.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 580 615 94.3 %
Date: 2017-09-14 15:23:50 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         203 : bool LLLexer::Error(LocTy ErrorLoc, const Twine &Msg) const {
      30         609 :   ErrorInfo = SM.GetMessage(ErrorLoc, SourceMgr::DK_Error, Msg);
      31         203 :   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     2981880 : uint64_t LLLexer::atoull(const char *Buffer, const char *End) {
      47     2981880 :   uint64_t Result = 0;
      48    12991260 :   for (; Buffer != End; Buffer++) {
      49     5004690 :     uint64_t OldRes = Result;
      50     5004690 :     Result *= 10;
      51     5004690 :     Result += *Buffer-'0';
      52     5004690 :     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        6424 : uint64_t LLLexer::HexIntToVal(const char *Buffer, const char *End) {
      61        6424 :   uint64_t Result = 0;
      62      189308 :   for (; Buffer != End; ++Buffer) {
      63       91443 :     uint64_t OldRes = Result;
      64       91443 :     Result *= 16;
      65      182886 :     Result += hexDigitValue(*Buffer);
      66             : 
      67       91443 :     if (Result < OldRes) {   // Uh, oh, overflow detected!!!
      68           2 :       Error("constant bigger than 64 bits detected!");
      69           1 :       return 0;
      70             :     }
      71             :   }
      72             :   return Result;
      73             : }
      74             : 
      75         201 : void LLLexer::HexToIntPair(const char *Buffer, const char *End,
      76             :                            uint64_t Pair[2]) {
      77         201 :   Pair[0] = 0;
      78         201 :   if (End - Buffer >= 16) {
      79        6600 :     for (int i = 0; i < 16; i++, Buffer++) {
      80             :       assert(Buffer != End);
      81        3200 :       Pair[0] *= 16;
      82        6400 :       Pair[0] += hexDigitValue(*Buffer);
      83             :     }
      84             :   }
      85         201 :   Pair[1] = 0;
      86        3403 :   for (int i = 0; i < 16 && Buffer != End; i++, Buffer++) {
      87        3202 :     Pair[1] *= 16;
      88        6404 :     Pair[1] += hexDigitValue(*Buffer);
      89             :   }
      90         201 :   if (Buffer != End)
      91           0 :     Error("constant bigger than 128 bits detected!");
      92         201 : }
      93             : 
      94             : /// FP80HexToIntPair - translate an 80 bit FP80 number (20 hexits) into
      95             : /// { low64, high16 } as usual for an APInt.
      96         136 : void LLLexer::FP80HexToIntPair(const char *Buffer, const char *End,
      97             :                            uint64_t Pair[2]) {
      98         136 :   Pair[1] = 0;
      99         677 :   for (int i=0; i<4 && Buffer != End; i++, Buffer++) {
     100             :     assert(Buffer != End);
     101         541 :     Pair[1] *= 16;
     102        1082 :     Pair[1] += hexDigitValue(*Buffer);
     103             :   }
     104         136 :   Pair[0] = 0;
     105        2296 :   for (int i = 0; i < 16 && Buffer != End; i++, Buffer++) {
     106        2160 :     Pair[0] *= 16;
     107        4320 :     Pair[0] += hexDigitValue(*Buffer);
     108             :   }
     109         136 :   if (Buffer != End)
     110           0 :     Error("constant bigger than 128 bits detected!");
     111         136 : }
     112             : 
     113             : // UnEscapeLexed - Run through the specified buffer and change \xx codes to the
     114             : // appropriate character.
     115      164319 : static void UnEscapeLexed(std::string &Str) {
     116      164319 :   if (Str.empty()) return;
     117             : 
     118      159318 :   char *Buffer = &Str[0], *EndBuffer = Buffer+Str.size();
     119      159318 :   char *BOut = Buffer;
     120      159318 :   for (char *BIn = Buffer; BIn != EndBuffer; ) {
     121     3327876 :     if (BIn[0] == '\\') {
     122        7814 :       if (BIn < EndBuffer-1 && BIn[1] == '\\') {
     123           7 :         *BOut++ = '\\'; // Two \ becomes one
     124           7 :         BIn += 2;
     125       15614 :       } else if (BIn < EndBuffer-2 &&
     126       15609 :                  isxdigit(static_cast<unsigned char>(BIn[1])) &&
     127        7802 :                  isxdigit(static_cast<unsigned char>(BIn[2]))) {
     128       23406 :         *BOut = hexDigitValue(BIn[1]) * 16 + hexDigitValue(BIn[2]);
     129        7802 :         BIn += 3;                           // Skip over handled chars
     130        7802 :         ++BOut;
     131             :       } else {
     132           5 :         *BOut++ = *BIn++;
     133             :       }
     134             :     } else {
     135     3320062 :       *BOut++ = *BIn++;
     136             :     }
     137             :   }
     138      159318 :   Str.resize(BOut-Buffer);
     139             : }
     140             : 
     141             : /// isLabelChar - Return true for [-a-zA-Z$._0-9].
     142    31450825 : static bool isLabelChar(char C) {
     143    41255216 :   return isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
     144    41253763 :          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      349510 :     if (CurPtr[0] == ':') return CurPtr+1;
     151      348882 :     if (!isLabelChar(CurPtr[0])) return nullptr;
     152      298105 :     ++CurPtr;
     153             :   }
     154             : }
     155             : 
     156             : //===----------------------------------------------------------------------===//
     157             : // Lexer definition.
     158             : //===----------------------------------------------------------------------===//
     159             : 
     160       28609 : LLLexer::LLLexer(StringRef StartBuf, SourceMgr &sm, SMDiagnostic &Err,
     161       28609 :                  LLVMContext &C)
     162       85827 :   : CurBuf(StartBuf), ErrorInfo(Err), SM(sm), Context(C), APFloatVal(0.0) {
     163       28609 :   CurPtr = CurBuf.begin();
     164       28609 : }
     165             : 
     166   178629311 : int LLLexer::getNextChar() {
     167   178629311 :   char CurChar = *CurPtr++;
     168   178629311 :   switch (CurChar) {
     169   178600817 :   default: return (unsigned char)CurChar;
     170       28494 :   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       56988 :     if (CurPtr-1 != CurBuf.end())
     174             :       return 0;  // Just whitespace.
     175             : 
     176             :     // Otherwise, return end of file.
     177       28492 :     --CurPtr;  // Another call to lex will return EOF again.
     178       28492 :     return EOF;
     179             :   }
     180             : }
     181             : 
     182    20413053 : lltok::Kind LLLexer::LexToken() {
     183             :   while (true) {
     184    45301629 :     TokStart = CurPtr;
     185             : 
     186    45301629 :     int CurChar = getNextChar();
     187    45301629 :     switch (CurChar) {
     188     7221922 :     default:
     189             :       // Handle letters: [a-zA-Z_]
     190     7221922 :       if (isalpha(static_cast<unsigned char>(CurChar)) || CurChar == '_')
     191     7221922 :         return LexIdentifier();
     192             : 
     193             :       return lltok::Error;
     194             :     case EOF: return lltok::Eof;
     195    21692600 :     case 0:
     196             :     case ' ':
     197             :     case '\t':
     198             :     case '\n':
     199             :     case '\r':
     200             :       // Ignore whitespace.
     201    21692600 :       continue;
     202           5 :     case '+': return LexPositive();
     203      431720 :     case '@': return LexAt();
     204         857 :     case '$': return LexDollar();
     205     2466619 :     case '%': return LexPercent();
     206       94267 :     case '"': return LexQuote();
     207       10380 :     case '.':
     208       20760 :       if (const char *Ptr = isLabelTail(CurPtr)) {
     209         604 :         CurPtr = Ptr;
     210        1208 :         StrVal.assign(TokStart, CurPtr-1);
     211         604 :         return lltok::LabelStr;
     212        9776 :       }
     213        9776 :       if (CurPtr[0] == '.' && CurPtr[1] == '.') {
     214        9776 :         CurPtr += 2;
     215        9776 :         return lltok::dotdotdot;
     216             :       }
     217             :       return lltok::Error;
     218     3195976 :     case ';':
     219     3195976 :       SkipLineComment();
     220     3195976 :       continue;
     221      223942 :     case '!': return LexExclaim();
     222       52086 :     case '#': return LexHash();
     223     2362068 :     case '0': case '1': case '2': case '3': case '4':
     224             :     case '5': case '6': case '7': case '8': case '9':
     225             :     case '-':
     226     2362068 :       return LexDigitOrNegative();
     227      846387 :     case '=': return lltok::equal;
     228      164893 :     case '[': return lltok::lsquare;
     229      164893 :     case ']': return lltok::rsquare;
     230      242220 :     case '{': return lltok::lbrace;
     231      242157 :     case '}': return lltok::rbrace;
     232      963573 :     case '<': return lltok::less;
     233      963573 :     case '>': return lltok::greater;
     234      518638 :     case '(': return lltok::lparen;
     235      518608 :     case ')': return lltok::rparen;
     236     2245083 :     case ',': return lltok::comma;
     237      650273 :     case '*': return lltok::star;
     238    24888988 :     case '|': return lltok::bar;
     239             :     }
     240             :   }
     241             : }
     242             : 
     243     3195976 : void LLLexer::SkipLineComment() {
     244             :   while (true) {
     245   133632645 :     if (CurPtr[0] == '\n' || CurPtr[0] == '\r' || getNextChar() == EOF)
     246     3195976 :       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      431720 : lltok::Kind LLLexer::LexAt() {
     255      431720 :   return LexVar(lltok::GlobalVar, lltok::GlobalID);
     256             : }
     257             : 
     258         857 : lltok::Kind LLLexer::LexDollar() {
     259        1714 :   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         857 :   if (CurPtr[0] == '"') {
     267         146 :     ++CurPtr;
     268             : 
     269             :     while (true) {
     270        2609 :       int CurChar = getNextChar();
     271             : 
     272        2609 :       if (CurChar == EOF) {
     273           0 :         Error("end of file in COMDAT variable name");
     274           0 :         return lltok::Error;
     275             :       }
     276        2609 :       if (CurChar == '"') {
     277         292 :         StrVal.assign(TokStart + 2, CurPtr - 1);
     278         146 :         UnEscapeLexed(StrVal);
     279         292 :         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         711 :   if (ReadVarName())
     290             :     return lltok::ComdatVar;
     291             : 
     292           0 :   return lltok::Error;
     293             : }
     294             : 
     295             : /// ReadString - Read a string until the closing quote.
     296       94267 : lltok::Kind LLLexer::ReadString(lltok::Kind kind) {
     297       94267 :   const char *Start = CurPtr;
     298             :   while (true) {
     299     2583360 :     int CurChar = getNextChar();
     300             : 
     301     2583360 :     if (CurChar == EOF) {
     302           0 :       Error("end of file in string constant");
     303           0 :       return lltok::Error;
     304             :     }
     305     2583360 :     if (CurChar == '"') {
     306      188534 :       StrVal.assign(Start, CurPtr-1);
     307       94267 :       UnEscapeLexed(StrVal);
     308       94267 :       return kind;
     309             :     }
     310             :   }
     311             : }
     312             : 
     313             : /// ReadVarName - Read the rest of a token containing a variable name.
     314     2888980 : bool LLLexer::ReadVarName() {
     315     2888980 :   const char *NameStart = CurPtr;
     316     2888980 :   if (isalpha(static_cast<unsigned char>(CurPtr[0])) ||
     317      478223 :       CurPtr[0] == '-' || CurPtr[0] == '$' ||
     318      467630 :       CurPtr[0] == '.' || CurPtr[0] == '_') {
     319     2500114 :     ++CurPtr;
     320    32408896 :     while (isalnum(static_cast<unsigned char>(CurPtr[0])) ||
     321     3929244 :            CurPtr[0] == '-' || CurPtr[0] == '$' ||
     322    18565124 :            CurPtr[0] == '.' || CurPtr[0] == '_')
     323    12988855 :       ++CurPtr;
     324             : 
     325     5000228 :     StrVal.assign(NameStart, CurPtr);
     326     2500114 :     return true;
     327             :   }
     328             :   return false;
     329             : }
     330             : 
     331     2898339 : lltok::Kind LLLexer::LexVar(lltok::Kind Var, lltok::Kind VarID) {
     332             :   // Handle StringConstant: \"[^\"]*\"
     333     2898339 :   if (CurPtr[0] == '"') {
     334       10070 :     ++CurPtr;
     335             : 
     336             :     while (true) {
     337      305029 :       int CurChar = getNextChar();
     338             : 
     339      305029 :       if (CurChar == EOF) {
     340           0 :         Error("end of file in global variable name");
     341           0 :         return lltok::Error;
     342             :       }
     343      305029 :       if (CurChar == '"') {
     344       20140 :         StrVal.assign(TokStart+2, CurPtr-1);
     345       10070 :         UnEscapeLexed(StrVal);
     346       20140 :         if (StringRef(StrVal).find_first_of(0) != StringRef::npos) {
     347           2 :           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     2888269 :   if (ReadVarName())
     357             :     return Var;
     358             : 
     359             :   // Handle VarID: [0-9]+
     360      388866 :   if (isdigit(static_cast<unsigned char>(CurPtr[0]))) {
     361      465966 :     for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
     362             :       /*empty*/;
     363             : 
     364      388866 :     uint64_t Val = atoull(TokStart+1, CurPtr);
     365      388866 :     if ((unsigned)Val != Val)
     366           0 :       Error("invalid value number (too large)!");
     367      388866 :     UIntVal = unsigned(Val);
     368      388866 :     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     2466619 : lltok::Kind LLLexer::LexPercent() {
     378     2466619 :   return LexVar(lltok::LocalVar, lltok::LocalVarID);
     379             : }
     380             : 
     381             : /// Lex all tokens that start with a " character.
     382             : ///   QuoteLabel        "[^"]+":
     383             : ///   StringConstant    "[^"]*"
     384       94267 : lltok::Kind LLLexer::LexQuote() {
     385       94267 :   lltok::Kind kind = ReadString(lltok::StringConstant);
     386       94267 :   if (kind == lltok::Error || kind == lltok::Eof)
     387             :     return kind;
     388             : 
     389       94267 :   if (CurPtr[0] == ':') {
     390         539 :     ++CurPtr;
     391        1078 :     if (StringRef(StrVal).find_first_of(0) != StringRef::npos) {
     392           2 :       Error("Null bytes are not allowed in names");
     393           1 :       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      223942 : lltok::Kind LLLexer::LexExclaim() {
     406             :   // Lex a metadata name as a MetadataVar.
     407      223942 :   if (isalpha(static_cast<unsigned char>(CurPtr[0])) ||
     408      164140 :       CurPtr[0] == '-' || CurPtr[0] == '$' ||
     409      164140 :       CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\') {
     410       59836 :     ++CurPtr;
     411     1125527 :     while (isalnum(static_cast<unsigned char>(CurPtr[0])) ||
     412       71419 :            CurPtr[0] == '-' || CurPtr[0] == '$' ||
     413      620246 :            CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\')
     414      497136 :       ++CurPtr;
     415             : 
     416      119672 :     StrVal.assign(TokStart+1, CurPtr);   // Skip !
     417       59836 :     UnEscapeLexed(StrVal);
     418       59836 :     return lltok::MetadataVar;
     419             :   }
     420             :   return lltok::exclaim;
     421             : }
     422             : 
     423             : /// Lex all tokens that start with a # character.
     424             : ///    AttrGrpID ::= #[0-9]+
     425       52086 : lltok::Kind LLLexer::LexHash() {
     426             :   // Handle AttrGrpID: #[0-9]+
     427       52086 :   if (isdigit(static_cast<unsigned char>(CurPtr[0]))) {
     428       52495 :     for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
     429             :       /*empty*/;
     430             : 
     431       52086 :     uint64_t Val = atoull(TokStart+1, CurPtr);
     432       52086 :     if ((unsigned)Val != Val)
     433           0 :       Error("invalid value number (too large)!");
     434       52086 :     UIntVal = unsigned(Val);
     435       52086 :     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     7221922 : lltok::Kind LLLexer::LexIdentifier() {
     447     7221922 :   const char *StartChar = CurPtr;
     448     7221922 :   const char *IntEnd = CurPtr[-1] == 'i' ? nullptr : StartChar;
     449             :   const char *KeywordEnd = nullptr;
     450             : 
     451    50257828 :   for (; isLabelChar(*CurPtr); ++CurPtr) {
     452             :     // If we decide this is an integer, remember the end of the sequence.
     453    21517953 :     if (!IntEnd && !isdigit(static_cast<unsigned char>(*CurPtr)))
     454      187516 :       IntEnd = CurPtr;
     455    21517953 :     if (!KeywordEnd && !isalnum(static_cast<unsigned char>(*CurPtr)) &&
     456             :         *CurPtr != '_')
     457       38367 :       KeywordEnd = CurPtr;
     458             :   }
     459             : 
     460             :   // If we stopped due to a colon, this really is a label.
     461     7221922 :   if (*CurPtr == ':') {
     462      499244 :     StrVal.assign(StartChar-1, CurPtr++);
     463      249622 :     return lltok::LabelStr;
     464             :   }
     465             : 
     466             :   // Otherwise, this wasn't a label.  If this was valid as an integer type,
     467             :   // return it.
     468     6972300 :   if (!IntEnd) IntEnd = CurPtr;
     469     6972300 :   if (IntEnd != StartChar) {
     470     2540928 :     CurPtr = IntEnd;
     471     2540928 :     uint64_t NumBits = atoull(StartChar, CurPtr);
     472     2540928 :     if (NumBits < IntegerType::MIN_INT_BITS ||
     473             :         NumBits > IntegerType::MAX_INT_BITS) {
     474           2 :       Error("bitwidth for integer type out of range!");
     475           1 :       return lltok::Error;
     476             :     }
     477     2540927 :     TyVal = IntegerType::get(Context, NumBits);
     478     2540927 :     return lltok::Type;
     479             :   }
     480             : 
     481             :   // Otherwise, this was a letter sequence.  See which keyword this is.
     482     4431372 :   if (!KeywordEnd) KeywordEnd = CurPtr;
     483     4431372 :   CurPtr = KeywordEnd;
     484     4431372 :   --StartChar;
     485     8862744 :   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     8853234 :   KEYWORD(true);    KEYWORD(false);
     494     8759054 :   KEYWORD(declare); KEYWORD(define);
     495     8321647 :   KEYWORD(global);  KEYWORD(constant);
     496             : 
     497     4146772 :   KEYWORD(private);
     498     4145195 :   KEYWORD(internal);
     499     4142085 :   KEYWORD(available_externally);
     500     4141958 :   KEYWORD(linkonce);
     501     4141821 :   KEYWORD(linkonce_odr);
     502     4141084 :   KEYWORD(weak); // Use as a linkage, and a modifier for "cmpxchg".
     503     4140542 :   KEYWORD(weak_odr);
     504     4140282 :   KEYWORD(appending);
     505     4139968 :   KEYWORD(dllimport);
     506     4139866 :   KEYWORD(dllexport);
     507     4139569 :   KEYWORD(common);
     508     4135403 :   KEYWORD(default);
     509     4135396 :   KEYWORD(hidden);
     510     4134687 :   KEYWORD(protected);
     511     4134583 :   KEYWORD(unnamed_addr);
     512     4132109 :   KEYWORD(local_unnamed_addr);
     513     4128687 :   KEYWORD(externally_initialized);
     514     4128660 :   KEYWORD(extern_weak);
     515     4128560 :   KEYWORD(external);
     516     4122607 :   KEYWORD(thread_local);
     517     4121950 :   KEYWORD(localdynamic);
     518     4121899 :   KEYWORD(initialexec);
     519     4121847 :   KEYWORD(localexec);
     520     4121802 :   KEYWORD(zeroinitializer);
     521     4103315 :   KEYWORD(undef);
     522     4030977 :   KEYWORD(null);
     523     4023081 :   KEYWORD(none);
     524     4022650 :   KEYWORD(to);
     525     3919350 :   KEYWORD(caller);
     526     3919067 :   KEYWORD(within);
     527     3918323 :   KEYWORD(from);
     528     3917986 :   KEYWORD(tail);
     529     3891687 :   KEYWORD(musttail);
     530     3891556 :   KEYWORD(notail);
     531     3891521 :   KEYWORD(target);
     532     3879932 :   KEYWORD(triple);
     533     3875470 :   KEYWORD(source_filename);
     534     3874116 :   KEYWORD(unwind);
     535     3871982 :   KEYWORD(deplibs);             // FIXME: Remove in 4.0.
     536     3871982 :   KEYWORD(datalayout);
     537     3864855 :   KEYWORD(volatile);
     538     3845180 :   KEYWORD(atomic);
     539     3843340 :   KEYWORD(unordered);
     540     3842964 :   KEYWORD(monotonic);
     541     3840694 :   KEYWORD(acquire);
     542     3839512 :   KEYWORD(release);
     543     3838764 :   KEYWORD(acq_rel);
     544     3838369 :   KEYWORD(seq_cst);
     545     3834057 :   KEYWORD(syncscope);
     546             : 
     547     3833262 :   KEYWORD(nnan);
     548     3832788 :   KEYWORD(ninf);
     549     3832720 :   KEYWORD(nsz);
     550     3832617 :   KEYWORD(arcp);
     551     3832515 :   KEYWORD(contract);
     552     3832479 :   KEYWORD(fast);
     553     3829200 :   KEYWORD(nuw);
     554     3823261 :   KEYWORD(nsw);
     555     3803315 :   KEYWORD(exact);
     556     3802847 :   KEYWORD(inbounds);
     557     3710671 :   KEYWORD(inrange);
     558     3710612 :   KEYWORD(align);
     559     3490073 :   KEYWORD(addrspace);
     560     3407539 :   KEYWORD(section);
     561     3406872 :   KEYWORD(alias);
     562     3406045 :   KEYWORD(ifunc);
     563     3406011 :   KEYWORD(module);
     564     3405792 :   KEYWORD(asm);
     565     3396900 :   KEYWORD(sideeffect);
     566     3389312 :   KEYWORD(alignstack);
     567     3389233 :   KEYWORD(inteldialect);
     568     3389209 :   KEYWORD(gc);
     569     3388888 :   KEYWORD(prefix);
     570     3388863 :   KEYWORD(prologue);
     571             : 
     572     3388798 :   KEYWORD(ccc);
     573     3388795 :   KEYWORD(fastcc);
     574     3387167 :   KEYWORD(coldcc);
     575     3387082 :   KEYWORD(x86_stdcallcc);
     576     3387001 :   KEYWORD(x86_fastcallcc);
     577     3386916 :   KEYWORD(x86_thiscallcc);
     578     3386647 :   KEYWORD(x86_vectorcallcc);
     579     3386583 :   KEYWORD(arm_apcscc);
     580     3386543 :   KEYWORD(arm_aapcscc);
     581     3386223 :   KEYWORD(arm_aapcs_vfpcc);
     582     3385506 :   KEYWORD(msp430_intrcc);
     583     3385493 :   KEYWORD(avr_intrcc);
     584     3385490 :   KEYWORD(avr_signalcc);
     585     3385487 :   KEYWORD(ptx_kernel);
     586     3385466 :   KEYWORD(ptx_device);
     587     3385281 :   KEYWORD(spir_kernel);
     588     3385259 :   KEYWORD(spir_func);
     589     3385217 :   KEYWORD(intel_ocl_bicc);
     590     3385149 :   KEYWORD(x86_64_sysvcc);
     591     3385138 :   KEYWORD(win64cc);
     592     3385092 :   KEYWORD(x86_regcallcc);
     593     3384892 :   KEYWORD(webkit_jscc);
     594     3384859 :   KEYWORD(swiftcc);
     595     3384427 :   KEYWORD(anyregcc);
     596     3384359 :   KEYWORD(preserve_mostcc);
     597     3384344 :   KEYWORD(preserve_allcc);
     598     3384333 :   KEYWORD(ghccc);
     599     3384277 :   KEYWORD(x86_intrcc);
     600     3384249 :   KEYWORD(hhvmcc);
     601     3384222 :   KEYWORD(hhvm_ccc);
     602     3384206 :   KEYWORD(cxx_fast_tlscc);
     603     3384098 :   KEYWORD(amdgpu_vs);
     604     3383986 :   KEYWORD(amdgpu_hs);
     605     3383977 :   KEYWORD(amdgpu_gs);
     606     3383955 :   KEYWORD(amdgpu_ps);
     607     3383352 :   KEYWORD(amdgpu_cs);
     608     3383340 :   KEYWORD(amdgpu_kernel);
     609             : 
     610     3366155 :   KEYWORD(cc);
     611     3366132 :   KEYWORD(c);
     612             : 
     613     3364412 :   KEYWORD(attributes);
     614             : 
     615     3357287 :   KEYWORD(alwaysinline);
     616     3357058 :   KEYWORD(allocsize);
     617     3357035 :   KEYWORD(argmemonly);
     618     3356785 :   KEYWORD(builtin);
     619     3356751 :   KEYWORD(byval);
     620     3355166 :   KEYWORD(inalloca);
     621     3354966 :   KEYWORD(cold);
     622     3354935 :   KEYWORD(convergent);
     623     3354794 :   KEYWORD(dereferenceable);
     624     3354430 :   KEYWORD(dereferenceable_or_null);
     625     3354398 :   KEYWORD(inaccessiblememonly);
     626     3354382 :   KEYWORD(inaccessiblemem_or_argmemonly);
     627     3354369 :   KEYWORD(inlinehint);
     628     3354228 :   KEYWORD(inreg);
     629     3352533 :   KEYWORD(jumptable);
     630     3352524 :   KEYWORD(minsize);
     631     3352008 :   KEYWORD(naked);
     632     3351986 :   KEYWORD(nest);
     633     3351927 :   KEYWORD(noalias);
     634     3346974 :   KEYWORD(nobuiltin);
     635     3346869 :   KEYWORD(nocapture);
     636     3336207 :   KEYWORD(noduplicate);
     637     3336179 :   KEYWORD(noimplicitfloat);
     638     3336135 :   KEYWORD(noinline);
     639     3335134 :   KEYWORD(norecurse);
     640     3334964 :   KEYWORD(nonlazybind);
     641     3334933 :   KEYWORD(nonnull);
     642     3333943 :   KEYWORD(noredzone);
     643     3333771 :   KEYWORD(noreturn);
     644     3333319 :   KEYWORD(nounwind);
     645     3267104 :   KEYWORD(optnone);
     646     3267018 :   KEYWORD(optsize);
     647     3265478 :   KEYWORD(readnone);
     648     3249326 :   KEYWORD(readonly);
     649     3244789 :   KEYWORD(returned);
     650     3244622 :   KEYWORD(returns_twice);
     651     3244550 :   KEYWORD(signext);
     652     3232298 :   KEYWORD(speculatable);
     653     3232173 :   KEYWORD(sret);
     654     3231152 :   KEYWORD(ssp);
     655     3226164 :   KEYWORD(sspreq);
     656     3226093 :   KEYWORD(sspstrong);
     657     3226025 :   KEYWORD(strictfp);
     658     3226020 :   KEYWORD(safestack);
     659     3225830 :   KEYWORD(sanitize_address);
     660     3225561 :   KEYWORD(sanitize_thread);
     661     3225496 :   KEYWORD(sanitize_memory);
     662     3225227 :   KEYWORD(swifterror);
     663     3224819 :   KEYWORD(swiftself);
     664     3224613 :   KEYWORD(uwtable);
     665     3220380 :   KEYWORD(writeonly);
     666     3220207 :   KEYWORD(zeroext);
     667             : 
     668     3213342 :   KEYWORD(type);
     669     3202183 :   KEYWORD(opaque);
     670             : 
     671     3201484 :   KEYWORD(comdat);
     672             : 
     673             :   // Comdat types
     674     3200245 :   KEYWORD(any);
     675     3199736 :   KEYWORD(exactmatch);
     676     3199731 :   KEYWORD(largest);
     677     3199688 :   KEYWORD(noduplicates);
     678     3199681 :   KEYWORD(samesize);
     679             : 
     680    15903427 :   KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle);
     681    15807926 :   KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge);
     682    15771569 :   KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole);
     683    15754272 :   KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une);
     684             : 
     685    15745827 :   KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax);
     686     3148163 :   KEYWORD(umin);
     687             : 
     688     3147826 :   KEYWORD(x);
     689     2118918 :   KEYWORD(blockaddress);
     690             : 
     691             :   // Metadata types.
     692     2118375 :   KEYWORD(distinct);
     693             : 
     694             :   // Use-list order directives.
     695     2113249 :   KEYWORD(uselistorder);
     696     2112402 :   KEYWORD(uselistorder_bb);
     697             : 
     698     2112390 :   KEYWORD(personality);
     699     2111450 :   KEYWORD(cleanup);
     700     2110811 :   KEYWORD(catch);
     701     2110410 :   KEYWORD(filter);
     702             : 
     703             : #undef KEYWORD
     704             : 
     705             :   // Keywords for types.
     706             : #define TYPEKEYWORD(STR, LLVMTY)                                               \
     707             :   do {                                                                         \
     708             :     if (Keyword == STR) {                                                      \
     709             :       TyVal = LLVMTY;                                                          \
     710             :       return lltok::Type;                                                      \
     711             :     }                                                                          \
     712             :   } while (false)
     713             : 
     714     2288696 :   TYPEKEYWORD("void",      Type::getVoidTy(Context));
     715     1960808 :   TYPEKEYWORD("half",      Type::getHalfTy(Context));
     716     2289908 :   TYPEKEYWORD("float",     Type::getFloatTy(Context));
     717     1699087 :   TYPEKEYWORD("double",    Type::getDoubleTy(Context));
     718     1336411 :   TYPEKEYWORD("x86_fp80",  Type::getX86_FP80Ty(Context));
     719     1337932 :   TYPEKEYWORD("fp128",     Type::getFP128Ty(Context));
     720     1326375 :   TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
     721     1437127 :   TYPEKEYWORD("label",     Type::getLabelTy(Context));
     722     1220964 :   TYPEKEYWORD("metadata",  Type::getMetadataTy(Context));
     723     1209787 :   TYPEKEYWORD("x86_mmx",   Type::getX86_MMXTy(Context));
     724     1198384 :   TYPEKEYWORD("token",     Type::getTokenTy(Context));
     725             : 
     726             : #undef TYPEKEYWORD
     727             : 
     728             :   // Keywords for instructions.
     729             : #define INSTKEYWORD(STR, Enum)                                                 \
     730             :   do {                                                                         \
     731             :     if (Keyword == #STR) {                                                     \
     732             :       UIntVal = Instruction::Enum;                                             \
     733             :       return lltok::kw_##STR;                                                  \
     734             :     }                                                                          \
     735             :   } while (false)
     736             : 
     737     1250537 :   INSTKEYWORD(add,   Add);  INSTKEYWORD(fadd,   FAdd);
     738     1155893 :   INSTKEYWORD(sub,   Sub);  INSTKEYWORD(fsub,   FSub);
     739     1146432 :   INSTKEYWORD(mul,   Mul);  INSTKEYWORD(fmul,   FMul);
     740     1116502 :   INSTKEYWORD(udiv,  UDiv); INSTKEYWORD(sdiv,  SDiv); INSTKEYWORD(fdiv,  FDiv);
     741     1107406 :   INSTKEYWORD(urem,  URem); INSTKEYWORD(srem,  SRem); INSTKEYWORD(frem,  FRem);
     742     1122024 :   INSTKEYWORD(shl,   Shl);  INSTKEYWORD(lshr,  LShr); INSTKEYWORD(ashr,  AShr);
     743     1110421 :   INSTKEYWORD(and,   And);  INSTKEYWORD(or,    Or);   INSTKEYWORD(xor,   Xor);
     744     1105372 :   INSTKEYWORD(icmp,  ICmp); INSTKEYWORD(fcmp,  FCmp);
     745             : 
     746     1026041 :   INSTKEYWORD(phi,         PHI);
     747     1092635 :   INSTKEYWORD(call,        Call);
     748      885155 :   INSTKEYWORD(trunc,       Trunc);
     749      882075 :   INSTKEYWORD(zext,        ZExt);
     750      869816 :   INSTKEYWORD(sext,        SExt);
     751      845256 :   INSTKEYWORD(fptrunc,     FPTrunc);
     752      844934 :   INSTKEYWORD(fpext,       FPExt);
     753      843869 :   INSTKEYWORD(uitofp,      UIToFP);
     754      841977 :   INSTKEYWORD(sitofp,      SIToFP);
     755      836404 :   INSTKEYWORD(fptoui,      FPToUI);
     756      835049 :   INSTKEYWORD(fptosi,      FPToSI);
     757      832113 :   INSTKEYWORD(inttoptr,    IntToPtr);
     758      830477 :   INSTKEYWORD(ptrtoint,    PtrToInt);
     759      875380 :   INSTKEYWORD(bitcast,     BitCast);
     760      777567 :   INSTKEYWORD(addrspacecast, AddrSpaceCast);
     761      793305 :   INSTKEYWORD(select,      Select);
     762      759369 :   INSTKEYWORD(va_arg,      VAArg);
     763      946229 :   INSTKEYWORD(ret,         Ret);
     764      640086 :   INSTKEYWORD(br,          Br);
     765      504624 :   INSTKEYWORD(switch,      Switch);
     766      502322 :   INSTKEYWORD(indirectbr,  IndirectBr);
     767      503494 :   INSTKEYWORD(invoke,      Invoke);
     768      500249 :   INSTKEYWORD(resume,      Resume);
     769      503192 :   INSTKEYWORD(unreachable, Unreachable);
     770             : 
     771      540327 :   INSTKEYWORD(alloca,      Alloca);
     772      590301 :   INSTKEYWORD(load,        Load);
     773      424679 :   INSTKEYWORD(store,       Store);
     774      205553 :   INSTKEYWORD(cmpxchg,     AtomicCmpXchg);
     775      208522 :   INSTKEYWORD(atomicrmw,   AtomicRMW);
     776      199394 :   INSTKEYWORD(fence,       Fence);
     777      314009 :   INSTKEYWORD(getelementptr, GetElementPtr);
     778             : 
     779       95863 :   INSTKEYWORD(extractelement, ExtractElement);
     780       91762 :   INSTKEYWORD(insertelement,  InsertElement);
     781       73425 :   INSTKEYWORD(shufflevector,  ShuffleVector);
     782       21293 :   INSTKEYWORD(extractvalue,   ExtractValue);
     783       14575 :   INSTKEYWORD(insertvalue,    InsertValue);
     784       12994 :   INSTKEYWORD(landingpad,     LandingPad);
     785       11137 :   INSTKEYWORD(cleanupret,     CleanupRet);
     786       11003 :   INSTKEYWORD(catchret,       CatchRet);
     787       10884 :   INSTKEYWORD(catchswitch,  CatchSwitch);
     788       10663 :   INSTKEYWORD(catchpad,     CatchPad);
     789       10383 :   INSTKEYWORD(cleanuppad,   CleanupPad);
     790             : 
     791             : #undef INSTKEYWORD
     792             : 
     793             : #define DWKEYWORD(TYPE, TOKEN)                                                 \
     794             :   do {                                                                         \
     795             :     if (Keyword.startswith("DW_" #TYPE "_")) {                                 \
     796             :       StrVal.assign(Keyword.begin(), Keyword.end());                           \
     797             :       return lltok::TOKEN;                                                     \
     798             :     }                                                                          \
     799             :   } while (false)
     800             : 
     801       15801 :   DWKEYWORD(TAG, DwarfTag);
     802        9136 :   DWKEYWORD(ATE, DwarfAttEncoding);
     803        5966 :   DWKEYWORD(VIRTUALITY, DwarfVirtuality);
     804        8622 :   DWKEYWORD(LANG, DwarfLang);
     805        4470 :   DWKEYWORD(CC, DwarfCC);
     806        5004 :   DWKEYWORD(OP, DwarfOp);
     807        4060 :   DWKEYWORD(MACINFO, DwarfMacinfo);
     808             : 
     809             : #undef DWKEYWORD
     810             : 
     811        6597 :   if (Keyword.startswith("DIFlag")) {
     812        5212 :     StrVal.assign(Keyword.begin(), Keyword.end());
     813        2606 :     return lltok::DIFlag;
     814             :   }
     815             : 
     816        1409 :   if (Keyword.startswith("CSK_")) {
     817          48 :     StrVal.assign(Keyword.begin(), Keyword.end());
     818          24 :     return lltok::ChecksumKind;
     819             :   }
     820             : 
     821        2610 :   if (Keyword == "NoDebug" || Keyword == "FullDebug" ||
     822         253 :       Keyword == "LineTablesOnly") {
     823        2498 :     StrVal.assign(Keyword.begin(), Keyword.end());
     824        1249 :     return lltok::EmissionKind;
     825             :   }
     826             : 
     827             :   // Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
     828             :   // the CFE to avoid forcing it to deal with 64-bit numbers.
     829         136 :   if ((TokStart[0] == 'u' || TokStart[0] == 's') &&
     830          72 :       TokStart[1] == '0' && TokStart[2] == 'x' &&
     831          24 :       isxdigit(static_cast<unsigned char>(TokStart[3]))) {
     832          24 :     int len = CurPtr-TokStart-3;
     833          24 :     uint32_t bits = len * 4;
     834          48 :     StringRef HexStr(TokStart + 3, len);
     835          24 :     if (!all_of(HexStr, isxdigit)) {
     836             :       // Bad token, return it as an error.
     837           1 :       CurPtr = TokStart+3;
     838           1 :       return lltok::Error;
     839             :     }
     840          23 :     APInt Tmp(bits, HexStr, 16);
     841          23 :     uint32_t activeBits = Tmp.getActiveBits();
     842          23 :     if (activeBits > 0 && activeBits < bits)
     843          66 :       Tmp = Tmp.trunc(activeBits);
     844         115 :     APSIntVal = APSInt(Tmp, TokStart[0] == 'u');
     845          23 :     return lltok::APSInt;
     846             :   }
     847             : 
     848             :   // If this is "cc1234", return this as just "cc".
     849          88 :   if (TokStart[0] == 'c' && TokStart[1] == 'c') {
     850          82 :     CurPtr = TokStart+2;
     851          82 :     return lltok::kw_cc;
     852             :   }
     853             : 
     854             :   // Finally, if this isn't known, return an error.
     855           6 :   CurPtr = TokStart+1;
     856           6 :   return lltok::Error;
     857             : }
     858             : 
     859             : /// Lex all tokens that start with a 0x prefix, knowing they match and are not
     860             : /// labels.
     861             : ///    HexFPConstant     0x[0-9A-Fa-f]+
     862             : ///    HexFP80Constant   0xK[0-9A-Fa-f]+
     863             : ///    HexFP128Constant  0xL[0-9A-Fa-f]+
     864             : ///    HexPPC128Constant 0xM[0-9A-Fa-f]+
     865             : ///    HexHalfConstant   0xH[0-9A-Fa-f]+
     866        6761 : lltok::Kind LLLexer::Lex0x() {
     867        6761 :   CurPtr = TokStart + 2;
     868             : 
     869             :   char Kind;
     870        6761 :   if ((CurPtr[0] >= 'K' && CurPtr[0] <= 'M') || CurPtr[0] == 'H') {
     871         672 :     Kind = *CurPtr++;
     872             :   } else {
     873             :     Kind = 'J';
     874             :   }
     875             : 
     876        6761 :   if (!isxdigit(static_cast<unsigned char>(CurPtr[0]))) {
     877             :     // Bad token, return it as an error.
     878           0 :     CurPtr = TokStart+1;
     879           0 :     return lltok::Error;
     880             :   }
     881             : 
     882      207879 :   while (isxdigit(static_cast<unsigned char>(CurPtr[0])))
     883      100559 :     ++CurPtr;
     884             : 
     885        6761 :   if (Kind == 'J') {
     886             :     // HexFPConstant - Floating point constant represented in IEEE format as a
     887             :     // hexadecimal number for when exponential notation is not precise enough.
     888             :     // Half, Float, and double only.
     889       24356 :     APFloatVal = APFloat(APFloat::IEEEdouble(),
     890       24356 :                          APInt(64, HexIntToVal(TokStart + 2, CurPtr)));
     891        6089 :     return lltok::APFloat;
     892             :   }
     893             : 
     894             :   uint64_t Pair[2];
     895         672 :   switch (Kind) {
     896           0 :   default: llvm_unreachable("Unknown kind!");
     897         136 :   case 'K':
     898             :     // F80HexFPConstant - x87 long double in hexadecimal format (10 bytes)
     899         136 :     FP80HexToIntPair(TokStart+3, CurPtr, Pair);
     900         680 :     APFloatVal = APFloat(APFloat::x87DoubleExtended(), APInt(80, Pair));
     901         136 :     return lltok::APFloat;
     902         134 :   case 'L':
     903             :     // F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes)
     904         134 :     HexToIntPair(TokStart+3, CurPtr, Pair);
     905         670 :     APFloatVal = APFloat(APFloat::IEEEquad(), APInt(128, Pair));
     906         134 :     return lltok::APFloat;
     907          67 :   case 'M':
     908             :     // PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes)
     909          67 :     HexToIntPair(TokStart+3, CurPtr, Pair);
     910         335 :     APFloatVal = APFloat(APFloat::PPCDoubleDouble(), APInt(128, Pair));
     911          67 :     return lltok::APFloat;
     912         335 :   case 'H':
     913        1340 :     APFloatVal = APFloat(APFloat::IEEEhalf(),
     914        1340 :                          APInt(16,HexIntToVal(TokStart+3, CurPtr)));
     915         335 :     return lltok::APFloat;
     916             :   }
     917             : }
     918             : 
     919             : /// Lex tokens for a label or a numeric constant, possibly starting with -.
     920             : ///    Label             [-a-zA-Z$._0-9]+:
     921             : ///    NInteger          -[0-9]+
     922             : ///    FPConstant        [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
     923             : ///    PInteger          [0-9]+
     924             : ///    HexFPConstant     0x[0-9A-Fa-f]+
     925             : ///    HexFP80Constant   0xK[0-9A-Fa-f]+
     926             : ///    HexFP128Constant  0xL[0-9A-Fa-f]+
     927             : ///    HexPPC128Constant 0xM[0-9A-Fa-f]+
     928     2362068 : lltok::Kind LLLexer::LexDigitOrNegative() {
     929             :   // If the letter after the negative is not a number, this is probably a label.
     930     2406002 :   if (!isdigit(static_cast<unsigned char>(TokStart[0])) &&
     931       43934 :       !isdigit(static_cast<unsigned char>(CurPtr[0]))) {
     932             :     // Okay, this is not a number after the -, it's probably a label.
     933           0 :     if (const char *End = isLabelTail(CurPtr)) {
     934           0 :       StrVal.assign(TokStart, End-1);
     935           0 :       CurPtr = End;
     936           0 :       return lltok::LabelStr;
     937             :     }
     938             : 
     939             :     return lltok::Error;
     940             :   }
     941             : 
     942             :   // At this point, it is either a label, int or fp constant.
     943             : 
     944             :   // Skip digits, we have at least one.
     945     3219079 :   for (; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
     946             :     /*empty*/;
     947             : 
     948             :   // Check to see if this really is a label afterall, e.g. "-1:".
     949     2362068 :   if (isLabelChar(CurPtr[0]) || CurPtr[0] == ':') {
     950       40168 :     if (const char *End = isLabelTail(CurPtr)) {
     951          48 :       StrVal.assign(TokStart, End-1);
     952          24 :       CurPtr = End;
     953          24 :       return lltok::LabelStr;
     954             :     }
     955             :   }
     956             : 
     957             :   // If the next character is a '.', then it is a fp value, otherwise its
     958             :   // integer.
     959     2362044 :   if (CurPtr[0] != '.') {
     960     2328804 :     if (TokStart[0] == '0' && TokStart[1] == 'x')
     961        6761 :       return Lex0x();
     962     6966129 :     APSIntVal = APSInt(StringRef(TokStart, CurPtr - TokStart));
     963     2322043 :     return lltok::APSInt;
     964             :   }
     965             : 
     966       33240 :   ++CurPtr;
     967             : 
     968             :   // Skip over [0-9]*([eE][-+]?[0-9]+)?
     969      250562 :   while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
     970             : 
     971       33240 :   if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
     972       45339 :     if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
     973       15071 :         ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
     974       15071 :           isdigit(static_cast<unsigned char>(CurPtr[2])))) {
     975       15197 :       CurPtr += 2;
     976       45460 :       while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
     977             :     }
     978             :   }
     979             : 
     980      132960 :   APFloatVal = APFloat(APFloat::IEEEdouble(),
     981       66480 :                        StringRef(TokStart, CurPtr - TokStart));
     982       33240 :   return lltok::APFloat;
     983             : }
     984             : 
     985             : /// Lex a floating point constant starting with +.
     986             : ///    FPConstant  [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
     987           5 : lltok::Kind LLLexer::LexPositive() {
     988             :   // If the letter after the negative is a number, this is probably not a
     989             :   // label.
     990           5 :   if (!isdigit(static_cast<unsigned char>(CurPtr[0])))
     991             :     return lltok::Error;
     992             : 
     993             :   // Skip digits.
     994           5 :   for (++CurPtr; isdigit(static_cast<unsigned char>(CurPtr[0])); ++CurPtr)
     995             :     /*empty*/;
     996             : 
     997             :   // At this point, we need a '.'.
     998           5 :   if (CurPtr[0] != '.') {
     999           0 :     CurPtr = TokStart+1;
    1000           0 :     return lltok::Error;
    1001             :   }
    1002             : 
    1003           5 :   ++CurPtr;
    1004             : 
    1005             :   // Skip over [0-9]*([eE][-+]?[0-9]+)?
    1006          15 :   while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
    1007             : 
    1008           5 :   if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
    1009           0 :     if (isdigit(static_cast<unsigned char>(CurPtr[1])) ||
    1010           0 :         ((CurPtr[1] == '-' || CurPtr[1] == '+') &&
    1011           0 :         isdigit(static_cast<unsigned char>(CurPtr[2])))) {
    1012           0 :       CurPtr += 2;
    1013           0 :       while (isdigit(static_cast<unsigned char>(CurPtr[0]))) ++CurPtr;
    1014             :     }
    1015             :   }
    1016             : 
    1017          20 :   APFloatVal = APFloat(APFloat::IEEEdouble(),
    1018          10 :                        StringRef(TokStart, CurPtr - TokStart));
    1019           5 :   return lltok::APFloat;
    1020             : }

Generated by: LCOV version 1.13