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