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