LLLexer.cpp revision f3a789d931de6b5be729c33ff476fb20f0badbb1 
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/DerivedTypes.h"
16#include "llvm/Instruction.h"
17#include "llvm/LLVMContext.h"
18#include "llvm/ADT/Twine.h"
19#include "llvm/Assembly/Parser.h"
20#include "llvm/Support/ErrorHandling.h"
21#include "llvm/Support/MemoryBuffer.h"
22#include "llvm/Support/MathExtras.h"
23#include "llvm/Support/SourceMgr.h"
24#include "llvm/Support/raw_ostream.h"
25#include <cctype>
26#include <cstdio>
27#include <cstdlib>
28#include <cstring>
29using namespace llvm;
30
31bool LLLexer::Error(LocTy ErrorLoc, const Twine &Msg) const {
32  ErrorInfo = SM.GetMessage(ErrorLoc, Msg, "error");
33  return true;
34}
35
36//===----------------------------------------------------------------------===//
37// Helper functions.
38//===----------------------------------------------------------------------===//
39
40// atoull - Convert an ascii string of decimal digits into the unsigned long
41// long representation... this does not have to do input error checking,
42// because we know that the input will be matched by a suitable regex...
43//
44uint64_t LLLexer::atoull(const char *Buffer, const char *End) {
45  uint64_t Result = 0;
46  for (; Buffer != End; Buffer++) {
47    uint64_t OldRes = Result;
48    Result *= 10;
49    Result += *Buffer-'0';
50    if (Result < OldRes) {  // Uh, oh, overflow detected!!!
51      Error("constant bigger than 64 bits detected!");
52      return 0;
53    }
54  }
55  return Result;
56}
57
58uint64_t LLLexer::HexIntToVal(const char *Buffer, const char *End) {
59  uint64_t Result = 0;
60  for (; Buffer != End; ++Buffer) {
61    uint64_t OldRes = Result;
62    Result *= 16;
63    char C = *Buffer;
64    if (C >= '0' && C <= '9')
65      Result += C-'0';
66    else if (C >= 'A' && C <= 'F')
67      Result += C-'A'+10;
68    else if (C >= 'a' && C <= 'f')
69      Result += C-'a'+10;
70
71    if (Result < OldRes) {   // Uh, oh, overflow detected!!!
72      Error("constant bigger than 64 bits detected!");
73      return 0;
74    }
75  }
76  return Result;
77}
78
79void LLLexer::HexToIntPair(const char *Buffer, const char *End,
80                           uint64_t Pair[2]) {
81  Pair[0] = 0;
82  for (int i=0; i<16; i++, Buffer++) {
83    assert(Buffer != End);
84    Pair[0] *= 16;
85    char C = *Buffer;
86    if (C >= '0' && C <= '9')
87      Pair[0] += C-'0';
88    else if (C >= 'A' && C <= 'F')
89      Pair[0] += C-'A'+10;
90    else if (C >= 'a' && C <= 'f')
91      Pair[0] += C-'a'+10;
92  }
93  Pair[1] = 0;
94  for (int i=0; i<16 && Buffer != End; i++, Buffer++) {
95    Pair[1] *= 16;
96    char C = *Buffer;
97    if (C >= '0' && C <= '9')
98      Pair[1] += C-'0';
99    else if (C >= 'A' && C <= 'F')
100      Pair[1] += C-'A'+10;
101    else if (C >= 'a' && C <= 'f')
102      Pair[1] += C-'a'+10;
103  }
104  if (Buffer != End)
105    Error("constant bigger than 128 bits detected!");
106}
107
108/// FP80HexToIntPair - translate an 80 bit FP80 number (20 hexits) into
109/// { low64, high16 } as usual for an APInt.
110void LLLexer::FP80HexToIntPair(const char *Buffer, const char *End,
111                           uint64_t Pair[2]) {
112  Pair[1] = 0;
113  for (int i=0; i<4 && Buffer != End; i++, Buffer++) {
114    assert(Buffer != End);
115    Pair[1] *= 16;
116    char C = *Buffer;
117    if (C >= '0' && C <= '9')
118      Pair[1] += C-'0';
119    else if (C >= 'A' && C <= 'F')
120      Pair[1] += C-'A'+10;
121    else if (C >= 'a' && C <= 'f')
122      Pair[1] += C-'a'+10;
123  }
124  Pair[0] = 0;
125  for (int i=0; i<16; i++, Buffer++) {
126    Pair[0] *= 16;
127    char C = *Buffer;
128    if (C >= '0' && C <= '9')
129      Pair[0] += C-'0';
130    else if (C >= 'A' && C <= 'F')
131      Pair[0] += C-'A'+10;
132    else if (C >= 'a' && C <= 'f')
133      Pair[0] += C-'a'+10;
134  }
135  if (Buffer != End)
136    Error("constant bigger than 128 bits detected!");
137}
138
139// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
140// appropriate character.
141static void UnEscapeLexed(std::string &Str) {
142  if (Str.empty()) return;
143
144  char *Buffer = &Str[0], *EndBuffer = Buffer+Str.size();
145  char *BOut = Buffer;
146  for (char *BIn = Buffer; BIn != EndBuffer; ) {
147    if (BIn[0] == '\\') {
148      if (BIn < EndBuffer-1 && BIn[1] == '\\') {
149        *BOut++ = '\\'; // Two \ becomes one
150        BIn += 2;
151      } else if (BIn < EndBuffer-2 && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
152        char Tmp = BIn[3]; BIn[3] = 0;      // Terminate string
153        *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number
154        BIn[3] = Tmp;                       // Restore character
155        BIn += 3;                           // Skip over handled chars
156        ++BOut;
157      } else {
158        *BOut++ = *BIn++;
159      }
160    } else {
161      *BOut++ = *BIn++;
162    }
163  }
164  Str.resize(BOut-Buffer);
165}
166
167/// isLabelChar - Return true for [-a-zA-Z$._0-9].
168static bool isLabelChar(char C) {
169  return isalnum(C) || C == '-' || C == '$' || C == '.' || C == '_';
170}
171
172
173/// isLabelTail - Return true if this pointer points to a valid end of a label.
174static const char *isLabelTail(const char *CurPtr) {
175  while (1) {
176    if (CurPtr[0] == ':') return CurPtr+1;
177    if (!isLabelChar(CurPtr[0])) return 0;
178    ++CurPtr;
179  }
180}
181
182
183
184//===----------------------------------------------------------------------===//
185// Lexer definition.
186//===----------------------------------------------------------------------===//
187
188LLLexer::LLLexer(MemoryBuffer *StartBuf, SourceMgr &sm, SMDiagnostic &Err,
189                 LLVMContext &C)
190  : CurBuf(StartBuf), ErrorInfo(Err), SM(sm), Context(C), APFloatVal(0.0) {
191  CurPtr = CurBuf->getBufferStart();
192}
193
194std::string LLLexer::getFilename() const {
195  return CurBuf->getBufferIdentifier();
196}
197
198int LLLexer::getNextChar() {
199  char CurChar = *CurPtr++;
200  switch (CurChar) {
201  default: return (unsigned char)CurChar;
202  case 0:
203    // A nul character in the stream is either the end of the current buffer or
204    // a random nul in the file.  Disambiguate that here.
205    if (CurPtr-1 != CurBuf->getBufferEnd())
206      return 0;  // Just whitespace.
207
208    // Otherwise, return end of file.
209    --CurPtr;  // Another call to lex will return EOF again.
210    return EOF;
211  }
212}
213
214
215lltok::Kind LLLexer::LexToken() {
216  TokStart = CurPtr;
217
218  int CurChar = getNextChar();
219  switch (CurChar) {
220  default:
221    // Handle letters: [a-zA-Z_]
222    if (isalpha(CurChar) || CurChar == '_')
223      return LexIdentifier();
224
225    return lltok::Error;
226  case EOF: return lltok::Eof;
227  case 0:
228  case ' ':
229  case '\t':
230  case '\n':
231  case '\r':
232    // Ignore whitespace.
233    return LexToken();
234  case '+': return LexPositive();
235  case '@': return LexAt();
236  case '%': return LexPercent();
237  case '"': return LexQuote();
238  case '.':
239    if (const char *Ptr = isLabelTail(CurPtr)) {
240      CurPtr = Ptr;
241      StrVal.assign(TokStart, CurPtr-1);
242      return lltok::LabelStr;
243    }
244    if (CurPtr[0] == '.' && CurPtr[1] == '.') {
245      CurPtr += 2;
246      return lltok::dotdotdot;
247    }
248    return lltok::Error;
249  case '$':
250    if (const char *Ptr = isLabelTail(CurPtr)) {
251      CurPtr = Ptr;
252      StrVal.assign(TokStart, CurPtr-1);
253      return lltok::LabelStr;
254    }
255    return lltok::Error;
256  case ';':
257    SkipLineComment();
258    return LexToken();
259  case '!': return LexExclaim();
260  case '0': case '1': case '2': case '3': case '4':
261  case '5': case '6': case '7': case '8': case '9':
262  case '-':
263    return LexDigitOrNegative();
264  case '=': return lltok::equal;
265  case '[': return lltok::lsquare;
266  case ']': return lltok::rsquare;
267  case '{': return lltok::lbrace;
268  case '}': return lltok::rbrace;
269  case '<': return lltok::less;
270  case '>': return lltok::greater;
271  case '(': return lltok::lparen;
272  case ')': return lltok::rparen;
273  case ',': return lltok::comma;
274  case '*': return lltok::star;
275  case '\\': return lltok::backslash;
276  }
277}
278
279void LLLexer::SkipLineComment() {
280  while (1) {
281    if (CurPtr[0] == '\n' || CurPtr[0] == '\r' || getNextChar() == EOF)
282      return;
283  }
284}
285
286/// LexAt - Lex all tokens that start with an @ character:
287///   GlobalVar   @\"[^\"]*\"
288///   GlobalVar   @[-a-zA-Z$._][-a-zA-Z$._0-9]*
289///   GlobalVarID @[0-9]+
290lltok::Kind LLLexer::LexAt() {
291  // Handle AtStringConstant: @\"[^\"]*\"
292  if (CurPtr[0] == '"') {
293    ++CurPtr;
294
295    while (1) {
296      int CurChar = getNextChar();
297
298      if (CurChar == EOF) {
299        Error("end of file in global variable name");
300        return lltok::Error;
301      }
302      if (CurChar == '"') {
303        StrVal.assign(TokStart+2, CurPtr-1);
304        UnEscapeLexed(StrVal);
305        return lltok::GlobalVar;
306      }
307    }
308  }
309
310  // Handle GlobalVarName: @[-a-zA-Z$._][-a-zA-Z$._0-9]*
311  if (ReadVarName())
312    return lltok::GlobalVar;
313
314  // Handle GlobalVarID: @[0-9]+
315  if (isdigit(CurPtr[0])) {
316    for (++CurPtr; isdigit(CurPtr[0]); ++CurPtr)
317      /*empty*/;
318
319    uint64_t Val = atoull(TokStart+1, CurPtr);
320    if ((unsigned)Val != Val)
321      Error("invalid value number (too large)!");
322    UIntVal = unsigned(Val);
323    return lltok::GlobalID;
324  }
325
326  return lltok::Error;
327}
328
329/// ReadString - Read a string until the closing quote.
330lltok::Kind LLLexer::ReadString(lltok::Kind kind) {
331  const char *Start = CurPtr;
332  while (1) {
333    int CurChar = getNextChar();
334
335    if (CurChar == EOF) {
336      Error("end of file in string constant");
337      return lltok::Error;
338    }
339    if (CurChar == '"') {
340      StrVal.assign(Start, CurPtr-1);
341      UnEscapeLexed(StrVal);
342      return kind;
343    }
344  }
345}
346
347/// ReadVarName - Read the rest of a token containing a variable name.
348bool LLLexer::ReadVarName() {
349  const char *NameStart = CurPtr;
350  if (isalpha(CurPtr[0]) || CurPtr[0] == '-' || CurPtr[0] == '$' ||
351      CurPtr[0] == '.' || CurPtr[0] == '_') {
352    ++CurPtr;
353    while (isalnum(CurPtr[0]) || CurPtr[0] == '-' || CurPtr[0] == '$' ||
354           CurPtr[0] == '.' || CurPtr[0] == '_')
355      ++CurPtr;
356
357    StrVal.assign(NameStart, CurPtr);
358    return true;
359  }
360  return false;
361}
362
363/// LexPercent - Lex all tokens that start with a % character:
364///   LocalVar   ::= %\"[^\"]*\"
365///   LocalVar   ::= %[-a-zA-Z$._][-a-zA-Z$._0-9]*
366///   LocalVarID ::= %[0-9]+
367lltok::Kind LLLexer::LexPercent() {
368  // Handle LocalVarName: %\"[^\"]*\"
369  if (CurPtr[0] == '"') {
370    ++CurPtr;
371    return ReadString(lltok::LocalVar);
372  }
373
374  // Handle LocalVarName: %[-a-zA-Z$._][-a-zA-Z$._0-9]*
375  if (ReadVarName())
376    return lltok::LocalVar;
377
378  // Handle LocalVarID: %[0-9]+
379  if (isdigit(CurPtr[0])) {
380    for (++CurPtr; isdigit(CurPtr[0]); ++CurPtr)
381      /*empty*/;
382
383    uint64_t Val = atoull(TokStart+1, CurPtr);
384    if ((unsigned)Val != Val)
385      Error("invalid value number (too large)!");
386    UIntVal = unsigned(Val);
387    return lltok::LocalVarID;
388  }
389
390  return lltok::Error;
391}
392
393/// LexQuote - Lex all tokens that start with a " character:
394///   QuoteLabel        "[^"]+":
395///   StringConstant    "[^"]*"
396lltok::Kind LLLexer::LexQuote() {
397  lltok::Kind kind = ReadString(lltok::StringConstant);
398  if (kind == lltok::Error || kind == lltok::Eof)
399    return kind;
400
401  if (CurPtr[0] == ':') {
402    ++CurPtr;
403    kind = lltok::LabelStr;
404  }
405
406  return kind;
407}
408
409/// LexExclaim:
410///    !foo
411///    !
412lltok::Kind LLLexer::LexExclaim() {
413  // Lex a metadata name as a MetadataVar.
414  if (isalpha(CurPtr[0]) || CurPtr[0] == '-' || CurPtr[0] == '$' ||
415      CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\') {
416    ++CurPtr;
417    while (isalnum(CurPtr[0]) || CurPtr[0] == '-' || CurPtr[0] == '$' ||
418           CurPtr[0] == '.' || CurPtr[0] == '_' || CurPtr[0] == '\\')
419      ++CurPtr;
420
421    StrVal.assign(TokStart+1, CurPtr);   // Skip !
422    UnEscapeLexed(StrVal);
423    return lltok::MetadataVar;
424  }
425  return lltok::exclaim;
426}
427
428/// LexIdentifier: Handle several related productions:
429///    Label           [-a-zA-Z$._0-9]+:
430///    IntegerType     i[0-9]+
431///    Keyword         sdiv, float, ...
432///    HexIntConstant  [us]0x[0-9A-Fa-f]+
433lltok::Kind LLLexer::LexIdentifier() {
434  const char *StartChar = CurPtr;
435  const char *IntEnd = CurPtr[-1] == 'i' ? 0 : StartChar;
436  const char *KeywordEnd = 0;
437
438  for (; isLabelChar(*CurPtr); ++CurPtr) {
439    // If we decide this is an integer, remember the end of the sequence.
440    if (!IntEnd && !isdigit(*CurPtr)) IntEnd = CurPtr;
441    if (!KeywordEnd && !isalnum(*CurPtr) && *CurPtr != '_') KeywordEnd = CurPtr;
442  }
443
444  // If we stopped due to a colon, this really is a label.
445  if (*CurPtr == ':') {
446    StrVal.assign(StartChar-1, CurPtr++);
447    return lltok::LabelStr;
448  }
449
450  // Otherwise, this wasn't a label.  If this was valid as an integer type,
451  // return it.
452  if (IntEnd == 0) IntEnd = CurPtr;
453  if (IntEnd != StartChar) {
454    CurPtr = IntEnd;
455    uint64_t NumBits = atoull(StartChar, CurPtr);
456    if (NumBits < IntegerType::MIN_INT_BITS ||
457        NumBits > IntegerType::MAX_INT_BITS) {
458      Error("bitwidth for integer type out of range!");
459      return lltok::Error;
460    }
461    TyVal = IntegerType::get(Context, NumBits);
462    return lltok::Type;
463  }
464
465  // Otherwise, this was a letter sequence.  See which keyword this is.
466  if (KeywordEnd == 0) KeywordEnd = CurPtr;
467  CurPtr = KeywordEnd;
468  --StartChar;
469  unsigned Len = CurPtr-StartChar;
470#define KEYWORD(STR) \
471  if (Len == strlen(#STR) && !memcmp(StartChar, #STR, strlen(#STR))) \
472    return lltok::kw_##STR;
473
474  KEYWORD(begin);   KEYWORD(end);
475  KEYWORD(true);    KEYWORD(false);
476  KEYWORD(declare); KEYWORD(define);
477  KEYWORD(global);  KEYWORD(constant);
478
479  KEYWORD(private);
480  KEYWORD(linker_private);
481  KEYWORD(linker_private_weak);
482  KEYWORD(linker_private_weak_def_auto);
483  KEYWORD(internal);
484  KEYWORD(available_externally);
485  KEYWORD(linkonce);
486  KEYWORD(linkonce_odr);
487  KEYWORD(weak);
488  KEYWORD(weak_odr);
489  KEYWORD(appending);
490  KEYWORD(dllimport);
491  KEYWORD(dllexport);
492  KEYWORD(common);
493  KEYWORD(default);
494  KEYWORD(hidden);
495  KEYWORD(protected);
496  KEYWORD(unnamed_addr);
497  KEYWORD(extern_weak);
498  KEYWORD(external);
499  KEYWORD(thread_local);
500  KEYWORD(zeroinitializer);
501  KEYWORD(undef);
502  KEYWORD(null);
503  KEYWORD(to);
504  KEYWORD(tail);
505  KEYWORD(target);
506  KEYWORD(triple);
507  KEYWORD(deplibs);
508  KEYWORD(datalayout);
509  KEYWORD(volatile);
510  KEYWORD(nuw);
511  KEYWORD(nsw);
512  KEYWORD(exact);
513  KEYWORD(inbounds);
514  KEYWORD(align);
515  KEYWORD(addrspace);
516  KEYWORD(section);
517  KEYWORD(alias);
518  KEYWORD(module);
519  KEYWORD(asm);
520  KEYWORD(sideeffect);
521  KEYWORD(alignstack);
522  KEYWORD(gc);
523
524  KEYWORD(ccc);
525  KEYWORD(fastcc);
526  KEYWORD(coldcc);
527  KEYWORD(x86_stdcallcc);
528  KEYWORD(x86_fastcallcc);
529  KEYWORD(x86_thiscallcc);
530  KEYWORD(arm_apcscc);
531  KEYWORD(arm_aapcscc);
532  KEYWORD(arm_aapcs_vfpcc);
533  KEYWORD(msp430_intrcc);
534  KEYWORD(ptx_kernel);
535  KEYWORD(ptx_device);
536
537  KEYWORD(cc);
538  KEYWORD(c);
539
540  KEYWORD(signext);
541  KEYWORD(zeroext);
542  KEYWORD(inreg);
543  KEYWORD(sret);
544  KEYWORD(nounwind);
545  KEYWORD(noreturn);
546  KEYWORD(noalias);
547  KEYWORD(nocapture);
548  KEYWORD(byval);
549  KEYWORD(nest);
550  KEYWORD(readnone);
551  KEYWORD(readonly);
552  KEYWORD(uwtable);
553
554  KEYWORD(inlinehint);
555  KEYWORD(noinline);
556  KEYWORD(alwaysinline);
557  KEYWORD(optsize);
558  KEYWORD(ssp);
559  KEYWORD(sspreq);
560  KEYWORD(noredzone);
561  KEYWORD(noimplicitfloat);
562  KEYWORD(naked);
563  KEYWORD(hotpatch);
564  KEYWORD(nonlazybind);
565
566  KEYWORD(type);
567  KEYWORD(opaque);
568
569  KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle);
570  KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge);
571  KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole);
572  KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une);
573
574  KEYWORD(x);
575  KEYWORD(blockaddress);
576#undef KEYWORD
577
578  // Keywords for types.
579#define TYPEKEYWORD(STR, LLVMTY) \
580  if (Len == strlen(STR) && !memcmp(StartChar, STR, strlen(STR))) { \
581    TyVal = LLVMTY; return lltok::Type; }
582  TYPEKEYWORD("void",      Type::getVoidTy(Context));
583  TYPEKEYWORD("float",     Type::getFloatTy(Context));
584  TYPEKEYWORD("double",    Type::getDoubleTy(Context));
585  TYPEKEYWORD("x86_fp80",  Type::getX86_FP80Ty(Context));
586  TYPEKEYWORD("fp128",     Type::getFP128Ty(Context));
587  TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
588  TYPEKEYWORD("label",     Type::getLabelTy(Context));
589  TYPEKEYWORD("metadata",  Type::getMetadataTy(Context));
590  TYPEKEYWORD("x86_mmx",   Type::getX86_MMXTy(Context));
591#undef TYPEKEYWORD
592
593  // Keywords for instructions.
594#define INSTKEYWORD(STR, Enum) \
595  if (Len == strlen(#STR) && !memcmp(StartChar, #STR, strlen(#STR))) { \
596    UIntVal = Instruction::Enum; return lltok::kw_##STR; }
597
598  INSTKEYWORD(add,   Add);  INSTKEYWORD(fadd,   FAdd);
599  INSTKEYWORD(sub,   Sub);  INSTKEYWORD(fsub,   FSub);
600  INSTKEYWORD(mul,   Mul);  INSTKEYWORD(fmul,   FMul);
601  INSTKEYWORD(udiv,  UDiv); INSTKEYWORD(sdiv,  SDiv); INSTKEYWORD(fdiv,  FDiv);
602  INSTKEYWORD(urem,  URem); INSTKEYWORD(srem,  SRem); INSTKEYWORD(frem,  FRem);
603  INSTKEYWORD(shl,   Shl);  INSTKEYWORD(lshr,  LShr); INSTKEYWORD(ashr,  AShr);
604  INSTKEYWORD(and,   And);  INSTKEYWORD(or,    Or);   INSTKEYWORD(xor,   Xor);
605  INSTKEYWORD(icmp,  ICmp); INSTKEYWORD(fcmp,  FCmp);
606
607  INSTKEYWORD(phi,         PHI);
608  INSTKEYWORD(call,        Call);
609  INSTKEYWORD(trunc,       Trunc);
610  INSTKEYWORD(zext,        ZExt);
611  INSTKEYWORD(sext,        SExt);
612  INSTKEYWORD(fptrunc,     FPTrunc);
613  INSTKEYWORD(fpext,       FPExt);
614  INSTKEYWORD(uitofp,      UIToFP);
615  INSTKEYWORD(sitofp,      SIToFP);
616  INSTKEYWORD(fptoui,      FPToUI);
617  INSTKEYWORD(fptosi,      FPToSI);
618  INSTKEYWORD(inttoptr,    IntToPtr);
619  INSTKEYWORD(ptrtoint,    PtrToInt);
620  INSTKEYWORD(bitcast,     BitCast);
621  INSTKEYWORD(select,      Select);
622  INSTKEYWORD(va_arg,      VAArg);
623  INSTKEYWORD(ret,         Ret);
624  INSTKEYWORD(br,          Br);
625  INSTKEYWORD(switch,      Switch);
626  INSTKEYWORD(indirectbr,  IndirectBr);
627  INSTKEYWORD(invoke,      Invoke);
628  INSTKEYWORD(unwind,      Unwind);
629  INSTKEYWORD(unreachable, Unreachable);
630
631  INSTKEYWORD(alloca,      Alloca);
632  INSTKEYWORD(load,        Load);
633  INSTKEYWORD(store,       Store);
634  INSTKEYWORD(getelementptr, GetElementPtr);
635
636  INSTKEYWORD(extractelement, ExtractElement);
637  INSTKEYWORD(insertelement,  InsertElement);
638  INSTKEYWORD(shufflevector,  ShuffleVector);
639  INSTKEYWORD(getresult,      ExtractValue);
640  INSTKEYWORD(extractvalue,   ExtractValue);
641  INSTKEYWORD(insertvalue,    InsertValue);
642#undef INSTKEYWORD
643
644  // Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
645  // the CFE to avoid forcing it to deal with 64-bit numbers.
646  if ((TokStart[0] == 'u' || TokStart[0] == 's') &&
647      TokStart[1] == '0' && TokStart[2] == 'x' && isxdigit(TokStart[3])) {
648    int len = CurPtr-TokStart-3;
649    uint32_t bits = len * 4;
650    APInt Tmp(bits, StringRef(TokStart+3, len), 16);
651    uint32_t activeBits = Tmp.getActiveBits();
652    if (activeBits > 0 && activeBits < bits)
653      Tmp = Tmp.trunc(activeBits);
654    APSIntVal = APSInt(Tmp, TokStart[0] == 'u');
655    return lltok::APSInt;
656  }
657
658  // If this is "cc1234", return this as just "cc".
659  if (TokStart[0] == 'c' && TokStart[1] == 'c') {
660    CurPtr = TokStart+2;
661    return lltok::kw_cc;
662  }
663
664  // Finally, if this isn't known, return an error.
665  CurPtr = TokStart+1;
666  return lltok::Error;
667}
668
669
670/// Lex0x: Handle productions that start with 0x, knowing that it matches and
671/// that this is not a label:
672///    HexFPConstant     0x[0-9A-Fa-f]+
673///    HexFP80Constant   0xK[0-9A-Fa-f]+
674///    HexFP128Constant  0xL[0-9A-Fa-f]+
675///    HexPPC128Constant 0xM[0-9A-Fa-f]+
676lltok::Kind LLLexer::Lex0x() {
677  CurPtr = TokStart + 2;
678
679  char Kind;
680  if (CurPtr[0] >= 'K' && CurPtr[0] <= 'M') {
681    Kind = *CurPtr++;
682  } else {
683    Kind = 'J';
684  }
685
686  if (!isxdigit(CurPtr[0])) {
687    // Bad token, return it as an error.
688    CurPtr = TokStart+1;
689    return lltok::Error;
690  }
691
692  while (isxdigit(CurPtr[0]))
693    ++CurPtr;
694
695  if (Kind == 'J') {
696    // HexFPConstant - Floating point constant represented in IEEE format as a
697    // hexadecimal number for when exponential notation is not precise enough.
698    // Float and double only.
699    APFloatVal = APFloat(BitsToDouble(HexIntToVal(TokStart+2, CurPtr)));
700    return lltok::APFloat;
701  }
702
703  uint64_t Pair[2];
704  switch (Kind) {
705  default: llvm_unreachable("Unknown kind!");
706  case 'K':
707    // F80HexFPConstant - x87 long double in hexadecimal format (10 bytes)
708    FP80HexToIntPair(TokStart+3, CurPtr, Pair);
709    APFloatVal = APFloat(APInt(80, 2, Pair));
710    return lltok::APFloat;
711  case 'L':
712    // F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes)
713    HexToIntPair(TokStart+3, CurPtr, Pair);
714    APFloatVal = APFloat(APInt(128, 2, Pair), true);
715    return lltok::APFloat;
716  case 'M':
717    // PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes)
718    HexToIntPair(TokStart+3, CurPtr, Pair);
719    APFloatVal = APFloat(APInt(128, 2, Pair));
720    return lltok::APFloat;
721  }
722}
723
724/// LexIdentifier: Handle several related productions:
725///    Label             [-a-zA-Z$._0-9]+:
726///    NInteger          -[0-9]+
727///    FPConstant        [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
728///    PInteger          [0-9]+
729///    HexFPConstant     0x[0-9A-Fa-f]+
730///    HexFP80Constant   0xK[0-9A-Fa-f]+
731///    HexFP128Constant  0xL[0-9A-Fa-f]+
732///    HexPPC128Constant 0xM[0-9A-Fa-f]+
733lltok::Kind LLLexer::LexDigitOrNegative() {
734  // If the letter after the negative is a number, this is probably a label.
735  if (!isdigit(TokStart[0]) && !isdigit(CurPtr[0])) {
736    // Okay, this is not a number after the -, it's probably a label.
737    if (const char *End = isLabelTail(CurPtr)) {
738      StrVal.assign(TokStart, End-1);
739      CurPtr = End;
740      return lltok::LabelStr;
741    }
742
743    return lltok::Error;
744  }
745
746  // At this point, it is either a label, int or fp constant.
747
748  // Skip digits, we have at least one.
749  for (; isdigit(CurPtr[0]); ++CurPtr)
750    /*empty*/;
751
752  // Check to see if this really is a label afterall, e.g. "-1:".
753  if (isLabelChar(CurPtr[0]) || CurPtr[0] == ':') {
754    if (const char *End = isLabelTail(CurPtr)) {
755      StrVal.assign(TokStart, End-1);
756      CurPtr = End;
757      return lltok::LabelStr;
758    }
759  }
760
761  // If the next character is a '.', then it is a fp value, otherwise its
762  // integer.
763  if (CurPtr[0] != '.') {
764    if (TokStart[0] == '0' && TokStart[1] == 'x')
765      return Lex0x();
766    unsigned Len = CurPtr-TokStart;
767    uint32_t numBits = ((Len * 64) / 19) + 2;
768    APInt Tmp(numBits, StringRef(TokStart, Len), 10);
769    if (TokStart[0] == '-') {
770      uint32_t minBits = Tmp.getMinSignedBits();
771      if (minBits > 0 && minBits < numBits)
772        Tmp = Tmp.trunc(minBits);
773      APSIntVal = APSInt(Tmp, false);
774    } else {
775      uint32_t activeBits = Tmp.getActiveBits();
776      if (activeBits > 0 && activeBits < numBits)
777        Tmp = Tmp.trunc(activeBits);
778      APSIntVal = APSInt(Tmp, true);
779    }
780    return lltok::APSInt;
781  }
782
783  ++CurPtr;
784
785  // Skip over [0-9]*([eE][-+]?[0-9]+)?
786  while (isdigit(CurPtr[0])) ++CurPtr;
787
788  if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
789    if (isdigit(CurPtr[1]) ||
790        ((CurPtr[1] == '-' || CurPtr[1] == '+') && isdigit(CurPtr[2]))) {
791      CurPtr += 2;
792      while (isdigit(CurPtr[0])) ++CurPtr;
793    }
794  }
795
796  APFloatVal = APFloat(std::atof(TokStart));
797  return lltok::APFloat;
798}
799
800///    FPConstant  [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
801lltok::Kind LLLexer::LexPositive() {
802  // If the letter after the negative is a number, this is probably not a
803  // label.
804  if (!isdigit(CurPtr[0]))
805    return lltok::Error;
806
807  // Skip digits.
808  for (++CurPtr; isdigit(CurPtr[0]); ++CurPtr)
809    /*empty*/;
810
811  // At this point, we need a '.'.
812  if (CurPtr[0] != '.') {
813    CurPtr = TokStart+1;
814    return lltok::Error;
815  }
816
817  ++CurPtr;
818
819  // Skip over [0-9]*([eE][-+]?[0-9]+)?
820  while (isdigit(CurPtr[0])) ++CurPtr;
821
822  if (CurPtr[0] == 'e' || CurPtr[0] == 'E') {
823    if (isdigit(CurPtr[1]) ||
824        ((CurPtr[1] == '-' || CurPtr[1] == '+') && isdigit(CurPtr[2]))) {
825      CurPtr += 2;
826      while (isdigit(CurPtr[0])) ++CurPtr;
827    }
828  }
829
830  APFloatVal = APFloat(std::atof(TokStart));
831  return lltok::APFloat;
832}
833