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